diff --git a/.github/scripts/build_test_apps.sh b/.github/scripts/build_test_apps.sh new file mode 100644 index 00000000..73032887 --- /dev/null +++ b/.github/scripts/build_test_apps.sh @@ -0,0 +1,14 @@ +#!/bin/bash +set -e + +pwd + +wget https://raw.githubusercontent.com/xmos/xmos_cmake_toolchain/main/xs3a.cmake +wget https://raw.githubusercontent.com/xmos/xmos_cmake_toolchain/main/xc_override.cmake +cmake -B build.xcore -DDEV_LIB_MIC_ARRAY=1 -DCMAKE_TOOLCHAIN_FILE=./xs3a.cmake +pushd build.xcore +make all +# I can't get the following two (custom) targets to build with 'all'. +# Currently an issue with java prevents these from working in CI. +# make tests-legacy_build +# make tests-legacy_build_vanilla diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..17dfc47e --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,54 @@ +# YAML schema for GitHub Actions: +# https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions +# +# Helpful YAML parser to clarify YAML syntax: +# https://yaml-online-parser.appspot.com/ +# +# This workflow uses actions that are not certified by GitHub. They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support documentation. +# +# This file contains the workflows that are run prior to merging a pull request. + +name: CI + +on: + push: + branches: + - 'develop' + - 'master' + pull_request: + branches: + - 'develop' + - 'master' + + # Allow manually triggering of the workflow. + workflow_dispatch: {} + +jobs: + build_tests_xcore: + name: Build Test Apps + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + with: + submodules: recursive + + - name: Pull builder container + run: | + docker pull ghcr.io/xmos/xcore_builder:latest + + - name: Install Python + uses: actions/setup-python@v2 + with: + python-version: '3.8' + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install numpy + + - name: Build + run: | + docker run --rm -w /lib_mic_array -v ${{ github.workspace }}:/lib_mic_array ghcr.io/xmos/xcore_builder:latest bash -l .github/scripts/build_test_apps.sh + diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 00000000..ec2a3993 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,57 @@ +# YAML schema for GitHub Actions: +# https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions +# +# Helpful YAML parser to clarify YAML syntax: +# https://yaml-online-parser.appspot.com/ +# +# This workflow uses actions that are not certified by GitHub. They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support documentation. +# +# This file contains the workflows that are run prior to merging a pull request. + +name: Docs + +on: + push: + branches: + - 'develop' + - 'master' + pull_request: + branches: + - 'develop' + - 'master' + + # Allow manually triggering of the workflow. + workflow_dispatch: {} + +jobs: + build_documentation: + name: Build and package documentation + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Pull doc_builder container + run: | + docker pull ghcr.io/xmos/doc_builder:v2.0.0 + + - name: Build documentation + run: | + docker run --rm -t -u "$(id -u):$(id -g)" -v ${{ github.workspace }}:/build -e REPO:/build -e DOXYGEN_INCLUDE=/build/doc/Doxyfile.inc -e EXCLUDE_PATTERNS=/build/doc/doc_excludes.txt -e DOXYGEN=1 -e DOXYGEN_INCLUDE=/build/doc/Doxyfile.inc -e PDF=1 ghcr.io/xmos/doc_builder:v2.0.0 + + - name: Save HTML documentation artifact + uses: actions/upload-artifact@v2 + with: + name: lib_mic_array_docs + path: ./doc/_build/html + if-no-files-found: error # 'warn' or 'ignore' are also available, defaults to `warn` + retention-days: 5 + + - name: Save PDF documentation artifact + uses: actions/upload-artifact@v2 + with: + name: lib_xcore_math_docs_pdf + path: ./doc/_build/pdf/programming_guide.pdf + if-no-files-found: error # 'warn' or 'ignore' are also available, defaults to `warn` + retention-days: 5 diff --git a/.gitignore b/.gitignore index 8847131e..35196d10 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,8 @@ **/.build*/* bin/ _build/ +xcore_sdk/ +.vscode/ *.o *.xe *.vcd @@ -31,6 +33,12 @@ tests/test_results.csv examples/AN00221_freq_domain_example/doc/pdf/AN00218.pdf examples/AN00218_app_hires_DAS_fixed/doc/pdf/AN00218.pdf **/.venv/** +**/__pycache__/ +**/.ipynb_checkpoints/ + +# Any files user wants to keep in their local clone +**/*.local.* +**/*.local.*/ # Unit test runners diff --git a/CHANGELOG.rst b/CHANGELOG.rst index aeda7b8c..27aff5b0 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -1,16 +1,38 @@ lib_mic_array change log ======================== -4.5.0 +5.0.2 ----- - * REMOVED: Use of Brew for CI - * CHANGED: XMOS Jenkins Shared Library version used in CI + * Documentation improvements. -4.4.0 +5.0.1 ----- + * Updates lib_mic_array to use lib_xcore_math (formerly lib_xs3_math) version 2.0.2 + * Updates CMake project to use CPM to obtain dependencies (when top level project) + * [issue #171] Changes behavior when mic array consumer gets backed up from a quiet deadlock to an ECALL exception + * Also adds a way to allow blocks of PDM to be quietly dropped instead (see AssertOnDroppedBlock()) + +5.0.0 +----- + + * Mic Array library redesigned from scratch to make efficient use of XMOS XS3 architecture + * Many unused features from previous versions have been dropped + * Initial v5.0 features: + + * Supports 1-, 4-, and 8-bit ports + * Supports both SDR and DDR microphone configurations + * Use 1-16 PDM microphones + * Configurable PDM clock frequency + * Configurable two-stage decimating FIR + + * Reference filter with total decimation factor of 192 provided + + * Optional DC offset elimination filter + * Configurable frame size (down to single sample) + * Extensible C++ design + - * CHANGED: XN files to support 15.x.x tools 4.3.0 ----- diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000..9ad32c78 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,58 @@ +cmake_minimum_required(VERSION 3.14) + + +# Disable in-source build. +if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}") + message(FATAL_ERROR "In-source build is not allowed! Please specify a build folder.\n\tex:cmake -B build") +endif() + +include(cmake/CPM.cmake) + +# if( PROJECT_IS_TOP_LEVEL ) +# message(STATUS "Configuring as top-level project") +# set( DEV_LIB_MIC_ARRAY 1 ) +# endif() + +# If DEV_LIB_MIC_ARRAY is not defined, set it to true iff the root +# build dir (CMAKE_BINARY_DIR) is a child of the current source dir. +# This will tell us whether to include the demos and tests. +if(NOT DEFINED DEV_LIB_MIC_ARRAY) + set(DEV_LIB_MIC_ARRAY 0) + get_filename_component(BIN_PARENT ${CMAKE_BINARY_DIR} DIRECTORY) + if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${BIN_PARENT}") + set(DEV_LIB_MIC_ARRAY 1) + endif() +endif() + +project(lib_mic_array + VERSION 5.0.1 + LANGUAGES CXX C ASM) + +if( PROJECT_IS_TOP_LEVEL OR ${DEV_LIB_MIC_ARRAY} ) + # Fixes issue where .xc files always recompile on Windows + string(REPLACE "-MD" "-MMD" CMAKE_DEPFILE_FLAGS_C ${CMAKE_DEPFILE_FLAGS_C}) +endif() + +# Add lib_mic_array +add_subdirectory(lib_mic_array) + +if( PROJECT_IS_TOP_LEVEL ) + set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}) +endif() + +# Make vanilla API macro available +include( etc/vanilla/vanilla.cmake ) + +#********************** +# Demos/Tests +#********************** + +if(${DEV_LIB_MIC_ARRAY}) + CPMAddPackage( + NAME lib_xcore_math + GIT_REPOSITORY https://github.com/xmos/lib_xcore_math + GIT_TAG v2.1.0 + ) + add_subdirectory( demos ) + add_subdirectory( tests ) +endif() diff --git a/Jenkinsfile b/Jenkinsfile deleted file mode 100644 index 26c1802f..00000000 --- a/Jenkinsfile +++ /dev/null @@ -1,68 +0,0 @@ -@Library('xmos_jenkins_shared_library@v0.18.0') _ -getApproval() - -pipeline { - agent { - label 'x86_64 && linux' - } - environment { - REPO = 'lib_mic_array' - VIEW = getViewName(REPO) - } - options { - skipDefaultCheckout() - } - stages { - stage('Get View') { - steps { - xcorePrepareSandbox("${VIEW}", "${REPO}") - } - } - stage('Library Checks') { - steps { - xcoreLibraryChecks("${REPO}") - } - } - stage('Unit tests') { - steps { - dir("${REPO}/tests/unit_tests") { - viewEnv() { - runWaf('.') - runPytest() - } - } - } - } - stage('Legacy Tests') { - steps { - dir("${REPO}/legacy_tests") { - viewEnv() { - // Use requirements.txt in legacy_tests, not lib_mic_array/requirements.txt - installPipfile(true) - runPython("./runtests.py --junit-output=${REPO}_tests.xml") - } - } - } - } - stage('Build') { - steps { - dir("${REPO}") { - xcoreAllAppsBuild('examples') - xcoreAllAppNotesBuild('examples') - } - runXdoc("${REPO}/${REPO}/doc") - - // Archive all the generated .pdf docs - archiveArtifacts artifacts: "${REPO}/**/pdf/*.pdf", fingerprint: true, allowEmptyArchive: true - } - } - } - post { - success { - updateViewfiles() - } - cleanup { - xcoreCleanSandbox() - } - } -} diff --git a/README.rst b/README.rst index 8806ba5a..1cd63e19 100644 --- a/README.rst +++ b/README.rst @@ -1,47 +1,31 @@ -Microphone array library +Microphone Array Library ======================== Summary ------- The XMOS microphone array library is designed to allow interfacing to PDM -microphones coupled with efficient decimation to user selectable output -sample rates. Additionally, a high resolution delay can be introduced to -each of the individual PDM microphones allowing for individual time shifts. -This library is only available for XS2 devices. +microphones coupled with efficient decimation to user configurable output +sample rates. This library is only available for XS3 devices. Features ........ The microphone array library has the following features: - - 48kHz, 24kHz, 16kHz, 12kHz and 8kHz output sample rate by default (3.072MHz PDM clock), - - 44.1kHz, 22.05kHz, 14.7kHz, 11.025kHz and 7.35kHz output sample rate by default (2.8224MHz PDM clock), - - 4, 8, 12 or 16 PDM interfaces per tile, - - No less than 70dB of stop band attenuation for all output sample frequencies, - - Configurable latency, ripple and bandwidth, - - Framing, configurable frame size from 1 sample to 8192 samples plus 50% overlapping frames option, - - Windowing and sample index bit reversal within a frame, - - Individual microphone gain compensation, - - DC offset removal, - - Up to 3.072MHz input sample rate, - - High resolution (2.63 microsecond) microphone specific delay lines, - - Every task requires only a 62.5 MIPS core to run, - - Group delay of a maximum of 18 output clock cycles, - - No less than 140dB of dynamic range. - -Components -........... - - * PDM interface, - * Four channel decimators, - * High resolution delay block. + - 48kHz, 24kHz, 16kHz, 12kHz and 8kHz output sample rate by default (3.072MHz PDM clock) + - Configurable PDM clock divider + - Use the provided reference decimation filter or supply your own + - 1 to 16 PDM microphones + - Supports both SDR and DDR microphone configurations + - Framing with configurable frame size + - DC offset removal + - Extensible C++ design Software version and dependencies ................................. The CHANGELOG contains information about the current and previous versions. -For a list of direct dependencies, look for DEPENDENT_MODULES in lib_mic_array/module_build_info. Related application notes ......................... diff --git a/cmake/CPM.cmake b/cmake/CPM.cmake new file mode 100644 index 00000000..76d24794 --- /dev/null +++ b/cmake/CPM.cmake @@ -0,0 +1,21 @@ +set(CPM_DOWNLOAD_VERSION 0.35.6) + +if(CPM_SOURCE_CACHE) + set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake") +elseif(DEFINED ENV{CPM_SOURCE_CACHE}) + set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake") +else() + set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake") +endif() + +# Expand relative path. This is important if the provided path contains a tilde (~) +get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE) +if(NOT (EXISTS ${CPM_DOWNLOAD_LOCATION})) + message(STATUS "Downloading CPM.cmake to ${CPM_DOWNLOAD_LOCATION}") + file(DOWNLOAD + https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake + ${CPM_DOWNLOAD_LOCATION} + ) +endif() + +include(${CPM_DOWNLOAD_LOCATION}) diff --git a/cmake/demo_app.cmake b/cmake/demo_app.cmake new file mode 100644 index 00000000..f49c244a --- /dev/null +++ b/cmake/demo_app.cmake @@ -0,0 +1,42 @@ + +macro( make_demo_app_target + TARGET_NAME + TARGET_SOURCE_FILES + TARGET_INCLUDE_PATHS + EXTRA_BUILD_FLAGS ) + + add_executable( ${TARGET_NAME} ) + + set(BUILD_FLAGS + "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_XN}" + "-fxscope" + "-mcmodel=large" + "-Wno-xcore-fptrgroup" + "-Wno-unknown-pragmas" + "-report" + "-g" + "-O2" + "-Wm,--map,memory.map" + "-DAPP_NAME=\"${TARGET_NAME}\"" + ) + + target_link_options( ${TARGET_NAME} PRIVATE + ${BUILD_FLAGS} ${EXTRA_BUILD_FLAGS} ) + + target_compile_options( ${TARGET_NAME} PRIVATE + ${BUILD_FLAGS} ${EXTRA_BUILD_FLAGS} ) + + target_sources( ${TARGET_NAME} PRIVATE ${TARGET_SOURCE_FILES} ) + + # set_source_file_properties( ${SOURCES_XC} PROPERTIES LANGUAGE C ) + + target_include_directories( ${TARGET_NAME} PRIVATE ${TARGET_INCLUDE_PATHS} ) + + target_link_libraries( ${TARGET_NAME} lib_xcore_math + lib_mic_array + framework_io_i2c + framework_io_i2s) + + install( TARGETS ${TARGET_NAME} ) + +endmacro() \ No newline at end of file diff --git a/cmake/demo_common.cmake b/cmake/demo_common.cmake new file mode 100644 index 00000000..f94aa0a9 --- /dev/null +++ b/cmake/demo_common.cmake @@ -0,0 +1,25 @@ + +# Just collects sources and includes for the common stuff + +set( DEMO_COMMON_FLAGS + "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_XN}" + "-fxscope" + "-mcmodel=large" + "-Wno-xcore-fptrgroup" + "-Wno-unknown-pragmas" + "-report" + "-g" + "-O2" + "-Wm,--map,memory.map" + "-DAPP_NAME=\"${APP_NAME}\"" +) + +set( DEMO_COMMON_DIR "${CMAKE_CURRENT_SOURCE_DIR}/common" ) + +set( DEMO_COMMON_INCLUDES "${DEMO_COMMON_DIR}/src" ) + +file( GLOB_RECURSE DEMO_COMMON_SOURCES + "${DEMO_COMMON_DIR}/src/*.c" + "${DEMO_COMMON_DIR}/src/*.xc" + "${DEMO_COMMON_DIR}/src/*.cpp" + "${DEMO_COMMON_DIR}/src/*.S" ) \ No newline at end of file diff --git a/cmake/unity/CMakeLists.txt b/cmake/unity/CMakeLists.txt new file mode 100644 index 00000000..977e3d9a --- /dev/null +++ b/cmake/unity/CMakeLists.txt @@ -0,0 +1,33 @@ + + +FetchContent_GetProperties( unity ) +if( NOT unity_POPULATED ) + FetchContent_Populate( unity ) +endif() + +add_library( unity INTERFACE ) + +target_sources( unity + PUBLIC + ${unity_SOURCE_DIR}/src/unity.c + ${unity_SOURCE_DIR}/extras/fixture/src/unity_fixture.c + ${unity_SOURCE_DIR}/extras/memory/src/unity_memory.c +) + +target_include_directories( unity + INTERFACE + ${unity_SOURCE_DIR}/src + ${unity_SOURCE_DIR}/extras/fixture/src/ + ${unity_SOURCE_DIR}/extras/memory/src/ + # ${CMAKE_CURRENT_SOURCE_DIR}/ +) + +target_compile_definitions( unity + INTERFACE + "UNITY_INCLUDE_CONFIG_H" +) + +target_compile_options( unity + INTERFACE + -Wno-xcore-fptrgroup +) \ No newline at end of file diff --git a/demos/CMakeLists.txt b/demos/CMakeLists.txt new file mode 100644 index 00000000..a80d9e03 --- /dev/null +++ b/demos/CMakeLists.txt @@ -0,0 +1,23 @@ + + +CPMAddPackage( + NAME fwk_io + GIT_REPOSITORY https://github.com/xmos/fwk_io + GIT_TAG 290c3ec127af4a4cdfdea482d168c16a5b6f4bc7 + GIT_SUBMODULES "" + DOWNLOAD_ONLY TRUE +) + + +add_subdirectory( ${fwk_io_SOURCE_DIR}/modules/i2c ${fwk_io_BINARY_DIR}/modules/i2c EXCLUDE_FROM_ALL) +add_subdirectory( ${fwk_io_SOURCE_DIR}/modules/i2s ${fwk_io_BINARY_DIR}/modules/i2s EXCLUDE_FROM_ALL) + + +add_custom_target( demos ) + +include(../cmake/demo_app.cmake) +include(../cmake/demo_common.cmake) + +add_subdirectory( demo ) +add_subdirectory( demo_vanilla ) +add_subdirectory( measure_mips ) \ No newline at end of file diff --git a/demos/common/src/app_common.h b/demos/common/src/app_common.h new file mode 100644 index 00000000..bb2f0bfb --- /dev/null +++ b/demos/common/src/app_common.h @@ -0,0 +1,39 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "app_config.h" + +#include "mic_array.h" +#include "util/audio_buffer.h" + +#include + + +#define I2S_CLKBLK XS1_CLKBLK_3 + +#if defined(__XC__) +# define static_const static const +#else +# define static_const const +#endif + +C_API_START + +void board_dac3101_init(); + +C_API_END + + +void eat_audio_frames_task( + chanend_t c_from_decimator, + static_const unsigned frame_words); + +void receive_and_buffer_audio_task( + chanend_t c_from_decimator, + audio_ring_buffer_t* output_buffer, + const unsigned mic_count, + const unsigned samples_per_frame, + static_const unsigned frame_words); + diff --git a/demos/common/src/app_common.xc b/demos/common/src/app_common.xc new file mode 100644 index 00000000..2967a547 --- /dev/null +++ b/demos/common/src/app_common.xc @@ -0,0 +1,40 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "app_common.h" + +void eat_audio_frames_task( + chanend_t c_from_decimator, + static const unsigned frame_words) +{ + int32_t audio_frame[frame_words]; + + while(1){ + ma_frame_rx(audio_frame, c_from_decimator, frame_words, 1); + } +} + +void receive_and_buffer_audio_task( + chanend_t c_from_decimator, + audio_ring_buffer_t* output_buffer, + const unsigned mic_count, + const unsigned samples_per_frame, + static const unsigned frame_words) +{ + int32_t audio_frame[frame_words]; + int32_t smp_buff[8]; + + while(1){ + + ma_frame_rx(audio_frame, c_from_decimator, frame_words, 1); + + for(int k = 0; k < frame_words; k++) + audio_frame[k] <<= 8; + + for(int k = 0; k < samples_per_frame; k++){ + for(int j = 0; j < mic_count; j++) + smp_buff[j] = audio_frame[k + samples_per_frame * j]; + abuff_frame_add( output_buffer, &smp_buff[0] ); + } + } +} diff --git a/demos/common/src/dac3101/dac3101.c b/demos/common/src/dac3101/dac3101.c new file mode 100644 index 00000000..6331dca6 --- /dev/null +++ b/demos/common/src/dac3101/dac3101.c @@ -0,0 +1,208 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include + +#include "i2c.h" + +#include "dac3101.h" +#include "../pcal6408a.h" + +#include "app_config.h" + +#include + +#define IOEXP_I2C_ADDR PCAL6408A_I2C_DEVICE_ADDR + +/* Set DAC_RST_N to 0 on the I2C expander (address 0x20) */ +static inline int reset_dac(i2c_master_t* ctx) +{ + i2c_regop_res_t ret; + ret = write_reg(ctx, IOEXP_I2C_ADDR, PCAL6408A_REG_CONFIG, 0xFF); + if (ret != I2C_REGOP_SUCCESS) { + printf("Failed to set io expander DAC_RST_N!\n"); + return -1; + } + delay_milliseconds(100); + ret = write_reg(ctx, IOEXP_I2C_ADDR, PCAL6408A_REG_CONFIG, 0xFB); + if (ret != I2C_REGOP_SUCCESS) { + printf("Failed to set io expander DAC_RST_N!!\n"); + return -1; + } + delay_milliseconds(100); + ret = write_reg(ctx, IOEXP_I2C_ADDR, PCAL6408A_REG_OUT_PORT, 0x04); + if (ret != I2C_REGOP_SUCCESS) { + printf("Failed to set io expander DAC_RST_N!!!\n"); + return -1; + } + delay_milliseconds(100); + + return ret; +} + + +/* + * Writes a value to a register in the DAC3101 DAC chip. + */ +static inline int dac3101_reg_write(i2c_master_t* ctx, + uint8_t reg, + uint8_t val) +{ + i2c_regop_res_t ret; + + ret = write_reg(ctx, DAC3101_I2C_DEVICE_ADDR, reg, val); + + if (ret == I2C_REGOP_SUCCESS) { + return 0; + } else { + return -1; + } +} + + + +/* + * Example configuration of the TLV320DAC3101 DAC using i2c. + * + * Must be called after the RTOS scheduler is started. + */ +int dac3101_init(i2c_master_t* ctx) +{ + reset_dac(ctx); + // This setup is for 1.024MHz in (BCLK), PLL of 98.304MHz 24.576MHz out and fs of 16kHz or + // or 3.072MHz BCLK, PLL of 98.304MHz 24.576MHz out and fs of 48kHz + const unsigned PLLP = 1; + const unsigned PLLR = 4; + const unsigned PLLJ = (APP_I2S_AUDIO_SAMPLE_RATE == 16000) ? 24 : 8; + const unsigned PLLD = 0; + const unsigned NDAC = 4; + const unsigned MDAC = (APP_I2S_AUDIO_SAMPLE_RATE == 16000) ? 6 : 4; + const unsigned DOSR = (APP_I2S_AUDIO_SAMPLE_RATE == 16000) ? 256 : 128; + + int code = 0; + + const char fail_fmt[] = "DAC init failed: %s\n"; + + do { + // Set register page to 0 + if( (code = dac3101_reg_write(ctx, DAC3101_PAGE_CTRL, 0x00)) ) + { printf(fail_fmt, "PAGE_CTRL"); break; } + + // Initiate SW reset (PLL is powered off as part of reset) + if( (code = dac3101_reg_write(ctx, DAC3101_SW_RST, 0x01)) ) + { printf(fail_fmt, "SW_RST"); break; } + + // Program clock settings + // Set PLL J Value + if( (code = dac3101_reg_write(ctx, DAC3101_PLL_J, PLLJ)) ) + { printf(fail_fmt, "PLL_J"); break; } + + // Set PLL D to... + if( (code = dac3101_reg_write(ctx, DAC3101_PLL_D_LSB, PLLD & 0xff)) ) + { printf(fail_fmt, "D_LSB"); break; } + + if( (code = dac3101_reg_write(ctx, DAC3101_PLL_D_MSB, (PLLD & 0xff00) >> 8)) ) + { printf(fail_fmt, "D_MSB"); break; } + + if( (code = dac3101_reg_write(ctx, DAC3101_B_DIV_VAL, 0x80 + 1)) ) + { printf(fail_fmt, "B_DIV_VAL"); break; } + + } while(0); + + if ( code == 0) { + // Wait for 1 ms + delay_milliseconds(1); + } else { + return -1; + } + + if ( + // Set PLL_CLKIN = BCLK (device pin), CODEC_CLKIN = PLL_CLK (generated on-chip) + dac3101_reg_write(ctx, DAC3101_CLK_GEN_MUX, (0b01 << 2) + 0b11) == 0 && + + // Set PLL P and R values and power up. + dac3101_reg_write(ctx, DAC3101_PLL_P_R, 0x80 + (PLLP << 4)+ PLLR) == 0 && + + // Set NDAC clock divider and power up. + dac3101_reg_write(ctx, DAC3101_NDAC_VAL, 0x80 + NDAC) == 0 && + // Set MDAC clock divider and power up. + dac3101_reg_write(ctx, DAC3101_MDAC_VAL, 0x80 + MDAC) == 0 && + // Set OSR clock divider to 256. + dac3101_reg_write(ctx, DAC3101_DOSR_VAL_LSB, DOSR & 0xff) == 0 && + dac3101_reg_write(ctx, DAC3101_DOSR_VAL_MSB, (DOSR & 0xff00) >> 8) == 0 && + + // Set CLKOUT Mux to DAC_CLK + dac3101_reg_write(ctx, DAC3101_CLKOUT_MUX, 0x04) == 0 && + // Set CLKOUT M divider to 1 and power up. + dac3101_reg_write(ctx, DAC3101_CLKOUT_M_VAL, 0x81) == 0 && + // Set GPIO1 output to come from CLKOUT output. + dac3101_reg_write(ctx, DAC3101_GPIO1_IO, 0x10) == 0 && + + // Set CODEC interface mode: I2S, 24 bit, slave mode (BCLK, WCLK both inputs). + dac3101_reg_write(ctx, DAC3101_CODEC_IF, 0x20) == 0 && + // Set register page to 1 + dac3101_reg_write(ctx, DAC3101_PAGE_CTRL, 0x01) == 0 && + // Program common-mode voltage to mid scale 1.65V. + dac3101_reg_write(ctx, DAC3101_HP_DRVR, 0x14) == 0 && + // Program headphone-specific depop settings. + // De-pop, Power on = 800 ms, Step time = 4 ms + dac3101_reg_write(ctx, DAC3101_HP_DEPOP, 0x4E) == 0 && + // Program routing of DAC output to the output amplifier (headphone/lineout or speaker) + // LDAC routed to left channel mixer amp, RDAC routed to right channel mixer amp + dac3101_reg_write(ctx, DAC3101_DAC_OP_MIX, 0x44) == 0 && + // Unmute and set gain of output driver + // Unmute HPL, set gain = 0 db + dac3101_reg_write(ctx, DAC3101_HPL_DRVR, 0x06) == 0 && + // Unmute HPR, set gain = 0 dB + dac3101_reg_write(ctx, DAC3101_HPR_DRVR, 0x06) == 0 && + // Unmute Left Class-D, set gain = 12 dB + dac3101_reg_write(ctx, DAC3101_SPKL_DRVR, 0x0C) == 0 && + // Unmute Right Class-D, set gain = 12 dB + dac3101_reg_write(ctx, DAC3101_SPKR_DRVR, 0x0C) == 0 && + // Power up output drivers + // HPL and HPR powered up + dac3101_reg_write(ctx, DAC3101_HP_DRVR, 0xD4) == 0 && + // Power-up L and R Class-D drivers + dac3101_reg_write(ctx, DAC3101_SPK_AMP, 0xC6) == 0 && + // Enable HPL output analog volume, set = -9 dB + dac3101_reg_write(ctx, DAC3101_HPL_VOL_A, 0x92) == 0 && + // Enable HPR output analog volume, set = -9 dB + dac3101_reg_write(ctx, DAC3101_HPR_VOL_A, 0x92) == 0 && + // Enable Left Class-D output analog volume, set = -9 dB + dac3101_reg_write(ctx, DAC3101_SPKL_VOL_A, 0x92) == 0 && + // Enable Right Class-D output analog volume, set = -9 dB + dac3101_reg_write(ctx, DAC3101_SPKR_VOL_A, 0x92) == 0 + ) { + // Wait for 100 ms + delay_milliseconds(100); + } else { + printf("DAC init failed section 2\n"); + return -1; + } + + if ( + // Power up DAC + // Set register page to 0 + dac3101_reg_write(ctx, DAC3101_PAGE_CTRL, 0x00) == 0 && + // Power up DAC channels and set digital gain + // Powerup DAC left and right channels (soft step enabled) + dac3101_reg_write(ctx, DAC3101_DAC_DAT_PATH, 0xD4) == 0 && + // DAC Left gain = 0dB + dac3101_reg_write(ctx, DAC3101_DACL_VOL_D, 0x00) == 0 && + // DAC Right gain = 0dB + dac3101_reg_write(ctx, DAC3101_DACR_VOL_D, 0x00) == 0 && + // Unmute digital volume control + // Unmute DAC left and right channels + dac3101_reg_write(ctx, DAC3101_DAC_VOL, 0x00) == 0 + ) { + // Wait for 100 ms + delay_milliseconds(100); + } else { + printf("DAC init failed section 3\n"); + return -1; + } + + return 0; +} diff --git a/demos/common/src/dac3101/dac3101.h b/demos/common/src/dac3101/dac3101.h new file mode 100644 index 00000000..a0f49639 --- /dev/null +++ b/demos/common/src/dac3101/dac3101.h @@ -0,0 +1,50 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#ifndef DAC3101_H_ +#define DAC3101_H_ + +#include "i2c.h" + +// TLV320DAC3101 Device I2C Address +#define DAC3101_I2C_DEVICE_ADDR 0x18 + +// TLV320DAC3101 Register Addresses +// Page 0 +#define DAC3101_PAGE_CTRL 0x00 // Register 0 - Page Control +#define DAC3101_SW_RST 0x01 // Register 1 - Software Reset +#define DAC3101_CLK_GEN_MUX 0x04 // Register 4 - Clock-Gen Muxing +#define DAC3101_PLL_P_R 0x05 // Register 5 - PLL P and R Values +#define DAC3101_PLL_J 0x06 // Register 6 - PLL J Value +#define DAC3101_PLL_D_MSB 0x07 // Register 7 - PLL D Value (MSB) +#define DAC3101_PLL_D_LSB 0x08 // Register 8 - PLL D Value (LSB) +#define DAC3101_NDAC_VAL 0x0B // Register 11 - NDAC Divider Value +#define DAC3101_MDAC_VAL 0x0C // Register 12 - MDAC Divider Value +#define DAC3101_DOSR_VAL_MSB 0x0D // Register 13 - DOSR Divider Value (MS Byte) +#define DAC3101_DOSR_VAL_LSB 0x0E // Register 14 - DOSR Divider Value (LS Byte) +#define DAC3101_CLKOUT_MUX 0x19 // Register 25 - CLKOUT MUX +#define DAC3101_CLKOUT_M_VAL 0x1A // Register 26 - CLKOUT M_VAL +#define DAC3101_CODEC_IF 0x1B // Register 27 - CODEC Interface Control +#define DAC3101_B_DIV_VAL 0x1E // Register 30 - BCLK Divider +#define DAC3101_DAC_DAT_PATH 0x3F // Register 63 - DAC Data Path Setup +#define DAC3101_DAC_VOL 0x40 // Register 64 - DAC Vol Control +#define DAC3101_DACL_VOL_D 0x41 // Register 65 - DAC Left Digital Vol Control +#define DAC3101_DACR_VOL_D 0x42 // Register 66 - DAC Right Digital Vol Control +#define DAC3101_GPIO1_IO 0x33 // Register 51 - GPIO1 In/Out Pin Control +// Page 1 +#define DAC3101_HP_DRVR 0x1F // Register 31 - Headphone Drivers +#define DAC3101_SPK_AMP 0x20 // Register 32 - Class-D Speaker Amp +#define DAC3101_HP_DEPOP 0x21 // Register 33 - Headphone Driver De-pop +#define DAC3101_DAC_OP_MIX 0x23 // Register 35 - DAC_L and DAC_R Output Mixer Routing +#define DAC3101_HPL_VOL_A 0x24 // Register 36 - Analog Volume to HPL +#define DAC3101_HPR_VOL_A 0x25 // Register 37 - Analog Volume to HPR +#define DAC3101_SPKL_VOL_A 0x26 // Register 38 - Analog Volume to Left Speaker +#define DAC3101_SPKR_VOL_A 0x27 // Register 39 - Analog Volume to Right Speaker +#define DAC3101_HPL_DRVR 0x28 // Register 40 - Headphone Left Driver +#define DAC3101_HPR_DRVR 0x29 // Register 41 - Headphone Right Driver +#define DAC3101_SPKL_DRVR 0x2A // Register 42 - Left Class-D Speaker Driver +#define DAC3101_SPKR_DRVR 0x2B // Register 43 - Right Class-D Speaker Driver + +int dac3101_init(i2c_master_t* ctx); + +#endif /* DAC3101_H_ */ diff --git a/demos/common/src/dac3101_init.c b/demos/common/src/dac3101_init.c new file mode 100644 index 00000000..7eead2b6 --- /dev/null +++ b/demos/common/src/dac3101_init.c @@ -0,0 +1,37 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include + +#include "i2c.h" +#include "i2s.h" + +#include "dac3101/dac3101.h" + +#define PDM_CLKBLK_1 XS1_CLKBLK_1 +#define PDM_CLKBLK_2 XS1_CLKBLK_2 + +i2c_master_t i2c_context; + + + +void board_dac3101_init() +{ + int res = 0; + + i2c_master_init(&i2c_context, + PORT_I2C_SCL, 0, 0, + PORT_I2C_SDA, 0, 0, + 100); + assert( res == 0 ); + + + res = dac3101_init(&i2c_context); + assert( res == 0 ); + + +} + diff --git a/demos/common/src/device_pll_ctrl.c b/demos/common/src/device_pll_ctrl.c new file mode 100644 index 00000000..0e393d41 --- /dev/null +++ b/demos/common/src/device_pll_ctrl.c @@ -0,0 +1,40 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include "device_pll_ctrl.h" + + +void device_pll_init(void) +{ + unsigned tileid = get_local_tile_id(); + + const unsigned DEVICE_PLL_DISABLE = 0x0201FF04; + const unsigned DEVICE_PLL_DIV_0 = 0x80000004; + + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_DISABLE); + + hwtimer_t tmr = hwtimer_alloc(); + { + xassert(tmr != 0); + hwtimer_delay(tmr, 100000); // 1ms with 100 MHz timer tick + } + hwtimer_free(tmr); + + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_CTL_VAL); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_CTL_VAL); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_FRAC_N_DIVIDER_NUM, + DEVICE_PLL_FRAC_NOM); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_CLK_DIVIDER_NUM, + DEVICE_PLL_DIV_0); +} \ No newline at end of file diff --git a/demos/common/src/device_pll_ctrl.h b/demos/common/src/device_pll_ctrl.h new file mode 100644 index 00000000..1186c82e --- /dev/null +++ b/demos/common/src/device_pll_ctrl.h @@ -0,0 +1,17 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "mic_array/api.h" + +C_API_START + + +#define DEVICE_PLL_CTL_VAL 0x0A019803 // Valid for all fractional values +#define DEVICE_PLL_FRAC_NOM 0x800095F9 // 24.576000 MHz + +MA_C_API +void device_pll_init(void); + +C_API_END \ No newline at end of file diff --git a/demos/common/src/pcal6408a.h b/demos/common/src/pcal6408a.h new file mode 100644 index 00000000..3e5e877d --- /dev/null +++ b/demos/common/src/pcal6408a.h @@ -0,0 +1,23 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#ifndef PCAL6408A_H_ +#define PCAL6408A_H_ + +// PCAL6408A I2C Address +#define PCAL6408A_I2C_DEVICE_ADDR 0x20 + +#define PCAL6408A_REG_IN_PORT 0x00 // Input Port +#define PCAL6408A_REG_OUT_PORT 0x01 // Output Port +#define PCAL6408A_REG_POLARITY_INV 0x02 // Polarity Inversion +#define PCAL6408A_REG_CONFIG 0x03 // Configuration +#define PCAL6408A_REG_OUT_DRIVE_STR0 0x40 // Output Drive Strength 0 +#define PCAL6408A_REG_OUT_DRIVE_STR1 0x41 // Output Drive Strength 1 +#define PCAL6408A_REG_IN_LATCH 0x42 // Input Latch +#define PCAL6408A_REG_PULL_UP_DOWN_EN 0x43 // Pull-up/pull-down enable +#define PCAL6408A_REG_PULL_UP_DOWN_SEL 0x44 // Pull-up/pull-down selection +#define PCAL6408A_REG_INT_MASK 0x45 // Interrupt Mask +#define PCAL6408A_REG_INT_STATUS 0x46 // Interrupt Status +#define PCAL6408A_REG_OUT_PORT_CONFIG 0x4F // Output Port Configuration + +#endif // PCAL6408_H_ diff --git a/demos/common/src/util/audio_buffer.c b/demos/common/src/util/audio_buffer.c new file mode 100644 index 00000000..aed218f4 --- /dev/null +++ b/demos/common/src/util/audio_buffer.c @@ -0,0 +1,41 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "audio_buffer.h" + +#include + + + +void abuff_frame_get( + audio_ring_buffer_t* rb, + int32_t frame[]) +{ + const unsigned chan_count = rb->config.channel_count; + + if(!rb->ready) { + memset(frame, 0, chan_count * sizeof(int32_t)); + } else { + memcpy(frame, &rb->audio[chan_count * rb->next_get], chan_count * sizeof(int32_t)); + + rb->next_get++; + if(rb->next_get >= rb->config.max_frames) + rb->next_get = 0; + } +} + + +void abuff_frame_add( + audio_ring_buffer_t* rb, + int32_t frame[]) +{ + const unsigned chan_count = rb->config.channel_count; + memcpy(&rb->audio[chan_count * rb->next_add], frame, chan_count * sizeof(int32_t)); + + rb->next_add++; + if(rb->next_add >= rb->config.max_frames) + rb->next_add = 0; + + if(!rb->ready && (rb->next_add == (rb->config.max_frames>>1))) + rb->ready = 1; +} diff --git a/demos/common/src/util/audio_buffer.h b/demos/common/src/util/audio_buffer.h new file mode 100644 index 00000000..a0cab595 --- /dev/null +++ b/demos/common/src/util/audio_buffer.h @@ -0,0 +1,56 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include + +#include "mic_array/api.h" +#include "util/audio_buffer.h" + +C_API_START + +MA_C_API +typedef struct { + int32_t* audio; + int next_add; + int next_get; + unsigned ready; + + struct { + unsigned max_frames; + unsigned channel_count; + } config; +} audio_ring_buffer_t; + + + + + +static inline +audio_ring_buffer_t abuff_init( + const unsigned channel_count, + const unsigned max_frames, + int32_t* mem_buffer) +{ + audio_ring_buffer_t ctx; + ctx.audio = mem_buffer; + ctx.next_add = 0; + ctx.next_get = 0; + ctx.ready = 0; + ctx.config.max_frames = max_frames; + ctx.config.channel_count = channel_count; + return ctx; +} + +MA_C_API +void abuff_frame_get( + audio_ring_buffer_t* rb, + int32_t frame[]); + +MA_C_API +void abuff_frame_add( + audio_ring_buffer_t* rb, + int32_t frame[]); + +C_API_END \ No newline at end of file diff --git a/demos/common/src/util/burn_mips.S b/demos/common/src/util/burn_mips.S new file mode 100644 index 00000000..91fcdf57 --- /dev/null +++ b/demos/common/src/util/burn_mips.S @@ -0,0 +1,42 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#if defined(__XS3A__) + +#include "xs1.h" + +/* + void burn_mips(); +*/ + +#define NSTACKWORDS (0) + +#define FUNCTION_NAME burn_mips + +.text +.issue_mode dual +.align 4 + +.cc_top FUNCTION_NAME.function,FUNCTION_NAME +FUNCTION_NAME: + dualentsp NSTACKWORDS + + .L_loop_back: + bu .L_loop_back + +.L_func_end: +.cc_bottom FUNCTION_NAME.function + + +.global FUNCTION_NAME +.type FUNCTION_NAME,@function + +.set FUNCTION_NAME.nstackwords,NSTACKWORDS; .global FUNCTION_NAME.nstackwords +.set FUNCTION_NAME.maxcores,1; .global FUNCTION_NAME.maxcores +.set FUNCTION_NAME.maxtimers,0; .global FUNCTION_NAME.maxtimers +.set FUNCTION_NAME.maxchanends,0; .global FUNCTION_NAME.maxchanends +.size FUNCTION_NAME, .L_func_end - FUNCTION_NAME + +#endif //defined(__XS3A__) + + diff --git a/demos/common/src/util/count_mips.S b/demos/common/src/util/count_mips.S new file mode 100644 index 00000000..e8b38297 --- /dev/null +++ b/demos/common/src/util/count_mips.S @@ -0,0 +1,106 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#if defined(__XS3A__) + +#include "xs1.h" + +/* + +Function for counting the MIPS available for a core. + +void count_mips(); + +*/ + + +.section .dp.data, "awd", @progbits + +.align 8 +tick_count: .word 0, 0 +inst_count: .word 0, 0 + +.global tick_count +.global inst_count + +#define NSTACKWORDS (0) + +#define FUNCTION_NAME count_mips + +#define p_tick_count r0 +#define p_inst_count r1 +#define last_time r2 +#define tick_lo r3 +#define tick_hi r4 +#define inst_lo r5 +#define inst_hi r6 +#define one r7 +#define tmp r8 + +.text +.issue_mode dual +.align 16 + +.cc_top FUNCTION_NAME.function,FUNCTION_NAME +FUNCTION_NAME: + dualentsp NSTACKWORDS + // Never returns, so no need to save any registers + + // Get pointers for the two counters + ldap r11, tick_count + mov p_tick_count, r11 + ldap r11, inst_count + mov p_inst_count, r11 + + // Initialize counters to 0 + { ldc tick_lo, 0 ; ldc tick_hi, 0 } + { ldc inst_lo, 0 ; ldc inst_hi, 0 } + + // maccu coefficient is one because we just want to add + { ldc one, 1 ; } + + // initialize the last timestamp, and jump to the loop + { gettime last_time ; bu .L_loop_top } + +# define LOOP_INST 8 + + .align 16 + .L_loop_top: + // this loop should be 8 thread cycles long (no FNOPS needed) + ldc tmp, LOOP_INST + // increment instruction counter + maccu inst_lo, inst_hi, one, tmp + + // Get current time + { gettime tmp ; } + // Subtract previous time (this approach should be immune to ref clock rollovers, + // rather than just subtracting a start time) + { sub tmp, tmp, last_time ; mov last_time, tmp } + // increment tick counter + maccu tick_lo, tick_hi, one, tmp + + // Store both counters in memory, and repeat + std tick_lo, tick_hi, p_tick_count[0] + std inst_lo, inst_hi, p_inst_count[0] + + { ; bu .L_loop_top } + .L_loop_bot: + + + +.L_func_end: +.cc_bottom FUNCTION_NAME.function + + +.global FUNCTION_NAME +.type FUNCTION_NAME,@function + +.set FUNCTION_NAME.nstackwords,NSTACKWORDS; .global FUNCTION_NAME.nstackwords +.set FUNCTION_NAME.maxcores,1; .global FUNCTION_NAME.maxcores +.set FUNCTION_NAME.maxtimers,0; .global FUNCTION_NAME.maxtimers +.set FUNCTION_NAME.maxchanends,0; .global FUNCTION_NAME.maxchanends +.size FUNCTION_NAME, .L_func_end - FUNCTION_NAME + +#endif //defined(__XS3A__) + + diff --git a/demos/common/src/util/mips.h b/demos/common/src/util/mips.h new file mode 100644 index 00000000..0a81cfc1 --- /dev/null +++ b/demos/common/src/util/mips.h @@ -0,0 +1,25 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include + +#include "mic_array/api.h" + +C_API_START; + +extern uint64_t tick_count; +extern uint64_t inst_count; + +MA_C_API +void burn_mips(); + +MA_C_API +void count_mips(); + +MA_C_API +void print_mips(const unsigned use_pdm_rx_isr); + + +C_API_END \ No newline at end of file diff --git a/demos/common/src/util/print_mips.c b/demos/common/src/util/print_mips.c new file mode 100644 index 00000000..1d573ea9 --- /dev/null +++ b/demos/common/src/util/print_mips.c @@ -0,0 +1,44 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "app_config.h" + +#include "mips.h" +#include "mic_array.h" + +#include +#include +#include +#include + +#include + + +void print_mips( + const unsigned use_pdm_rx_isr) +{ + + while(1){ + delay_seconds(1); + + uint64_t t = tick_count; + uint64_t c = inst_count; + + const float usec = t / 100.0f; // microseconds since the count started + const float ipus = c / usec; // instructions per microsecond + const float mips = ipus; // million instructions per second + // = million instructions per million microseconds + // = instructions per microsecond + + // We have 6 threads using [mips] MIPS, and one thread (mic array) using [ma_mips] MIPS.. + // 600 = 6*mips + ma_mips --> ma_mips = 600 - 6*mips + + unsigned burns = (use_pdm_rx_isr)? 6 : 5; + + const float ma_mips = 600 - burns*mips; + + + printf(" mic_array: %0.04f MIPS\n", ma_mips); + } + +} diff --git a/demos/demo/CMakeLists.txt b/demos/demo/CMakeLists.txt new file mode 100644 index 00000000..47ad588c --- /dev/null +++ b/demos/demo/CMakeLists.txt @@ -0,0 +1,43 @@ + +set( APP_NAME demo ) + +set( TARGET_XN XVF3610_Q60A.xn ) + +#********************** +# includes +#********************** + +set( APP_INCLUDES "src" ) +list( APPEND APP_INCLUDES ${DEMO_COMMON_INCLUDES} ) + +#********************** +# sources +#********************** + +file( GLOB_RECURSE APP_SOURCES "src/*.c" "src/*.xc" "src/*.cpp" "src/*.S" ) + +list( APPEND APP_SOURCES ${DEMO_COMMON_SOURCES} ) + +#********************** +# create targets +#********************** + +set( NAME_MAP thread;isr ) + +foreach( N_MICS 1 2 ) + foreach( USE_ISR 1 0 ) + + list( GET NAME_MAP ${USE_ISR} tmp ) + set( TARG_NAME "${APP_NAME}_${N_MICS}mic_${tmp}" ) + + unset(TARG_FLAGS) + list( APPEND TARG_FLAGS + "-DN_MICS=${N_MICS}" + "-DAPP_USE_PDM_RX_ISR=${USE_ISR}" ) + + make_demo_app_target( ${TARG_NAME} "${APP_SOURCES}" "${APP_INCLUDES}" "${TARG_FLAGS}" ) + + add_dependencies( demos ${TARG_NAME} ) + + endforeach() +endforeach() diff --git a/demos/demo/XVF3610_Q60A.xn b/demos/demo/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/demos/demo/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demos/demo/src/app.cpp b/demos/demo/src/app.cpp new file mode 100644 index 00000000..2e923f4c --- /dev/null +++ b/demos/demo/src/app.cpp @@ -0,0 +1,69 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "app.h" + +#include "mic_array/cpp/Prefab.hpp" + +#define DCOE_ENABLED true + + +#if (N_MICS != 2) +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_SDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + MIC_ARRAY_CLK1); +#else +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_DDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + MIC_ARRAY_CLK1, + MIC_ARRAY_CLK2); +#endif + + +using TMicArray = mic_array::prefab::BasicMicArray< + N_MICS, SAMPLES_PER_FRAME, DCOE_ENABLED>; + +TMicArray mics = TMicArray(); + +MA_C_API +void app_init() +{ + mics.Init(); + + // Configure our clocks and ports + const unsigned mclk_div = mic_array_mclk_divider( + APP_AUDIO_CLOCK_FREQUENCY, APP_PDM_CLOCK_FREQUENCY); + + mic_array_resources_configure(&pdm_res, mclk_div); + + mics.PdmRx.Init(pdm_res.p_pdm_mics); +} + +MA_C_API +void app_pdm_rx_task() +{ + mic_array_pdm_clock_start(&pdm_res); + mics.PdmRxThreadEntry(); +} + +MA_C_API +void app_decimator_task(chanend_t c_audio_frames) +{ + mics.SetOutputChannel(c_audio_frames); + +#if APP_USE_PDM_RX_ISR + // Start the PDM clock + mic_array_pdm_clock_start(&pdm_res); + + mics.InstallPdmRxISR(); + mics.UnmaskPdmRxISR(); +#endif + + mics.ThreadEntry(); +} + + diff --git a/demos/demo/src/app.h b/demos/demo/src/app.h new file mode 100644 index 00000000..c27206aa --- /dev/null +++ b/demos/demo/src/app.h @@ -0,0 +1,34 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "app_config.h" +#include "app_common.h" +#include "util/audio_buffer.h" +#include "mic_array.h" + +C_API_START + +/** + * @brief Application-specific intitialization + */ +MA_C_API +void app_init(); + +/** + * @brief C-compatible wrapper for PDM rx thread entry point + */ +MA_C_API +void app_pdm_rx_task(); + +/** + * @brief + */ +MA_C_API +void app_decimator_task(chanend_t c_audio_frames); + +MA_C_API +void app_i2s_task( audio_ring_buffer_t* audio_buff ); + +C_API_END \ No newline at end of file diff --git a/demos/demo/src/app_config.h b/demos/demo/src/app_config.h new file mode 100644 index 00000000..4e59c932 --- /dev/null +++ b/demos/demo/src/app_config.h @@ -0,0 +1,30 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + + +#ifndef N_MICS +# error "N_MICS not defined." +#endif + +#ifndef APP_USE_PDM_RX_ISR +# error "APP_USE_PDM_RX_ISR not defined." +#endif + + +#define SAMPLES_PER_FRAME 16 + +#define AUDIO_BUFFER_SAMPLES ((unsigned) (SAMPLES_PER_FRAME * 1.2f + 4)) + +#define APP_AUDIO_CLOCK_FREQUENCY 24576000 +#define APP_PDM_CLOCK_FREQUENCY 3072000 +#define APP_AUDIO_PIPELINE_SAMPLE_RATE 16000 + + +#define APP_I2S_AUDIO_SAMPLE_RATE APP_AUDIO_PIPELINE_SAMPLE_RATE + +#define APP_USE_DC_OFFSET_ELIMINATION 1 + +#define MIC_ARRAY_CLK1 XS1_CLKBLK_1 +#define MIC_ARRAY_CLK2 XS1_CLKBLK_2 diff --git a/demos/demo/src/app_i2s.c b/demos/demo/src/app_i2s.c new file mode 100644 index 00000000..b2c6ea59 --- /dev/null +++ b/demos/demo/src/app_i2s.c @@ -0,0 +1,114 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include + +#include "app.h" +#include "i2s.h" +#include "util/audio_buffer.h" + +#include "app_config.h" + +#include +#include +#include +#include +#include +#include + +#include + + +#define I2S_CLKBLK XS1_CLKBLK_3 + + + +static int i2s_mclk_bclk_ratio( + const unsigned audio_clock_frequency, + const unsigned sample_rate) +{ + return audio_clock_frequency / (sample_rate * (8 * sizeof(int32_t)) * I2S_CHANS_PER_FRAME); +} + + + + +I2S_CALLBACK_ATTR +void app_i2s_send(audio_ring_buffer_t* audio_buff, + size_t num_out, + int32_t* samples) +{ + int32_t frame[N_MICS]; + abuff_frame_get(audio_buff, frame); + + for(int c = 0; c < num_out; c++){ + int32_t samp = frame[(N_MICS==1)?0:c]; + samples[c] = samp; + } +} + + + +I2S_CALLBACK_ATTR +static +void app_i2s_init(void* app_data, + i2s_config_t* config) +{ + config->mode = I2S_MODE_I2S; + config->mclk_bclk_ratio = i2s_mclk_bclk_ratio(APP_AUDIO_CLOCK_FREQUENCY, APP_I2S_AUDIO_SAMPLE_RATE); +} + + + + +I2S_CALLBACK_ATTR +static +i2s_restart_t app_i2s_restart(void* app_data) +{ + static unsigned do_restart = 0; + i2s_restart_t res = do_restart? I2S_RESTART : I2S_NO_RESTART; + do_restart = 0; + return res; +} + + + + + +I2S_CALLBACK_ATTR +static +void app_i2s_receive(void* app_data, + size_t num_in, + const int32_t* samples) +{ + +} + + + +i2s_callback_group_t i2s_context = { + .init = (i2s_init_t) app_i2s_init, + .restart_check = (i2s_restart_check_t) app_i2s_restart, + .receive = (i2s_receive_t) app_i2s_receive, + .send = (i2s_send_t) app_i2s_send, + .app_data = NULL, +}; + + + +void app_i2s_task( audio_ring_buffer_t* app_context ) +{ + i2s_context.app_data = app_context; + + port_t p_i2s_dout[] = { I2S_DATA_IN }; + // port_t p_i2s_din[] = { I2S_DATA_IN }; + port_t p_i2s_din[0]; + + i2s_master(&i2s_context, + p_i2s_dout, 1, + p_i2s_din, 0, + PORT_I2S_BCLK, + PORT_I2S_LRCLK, + PORT_MCLK_IN_OUT, + I2S_CLKBLK); +} diff --git a/demos/demo/src/main.xc b/demos/demo/src/main.xc new file mode 100644 index 00000000..2f1d3e78 --- /dev/null +++ b/demos/demo/src/main.xc @@ -0,0 +1,82 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "app_config.h" +#include "util/mips.h" +#include "device_pll_ctrl.h" + +#include "app.h" +#include "app_common.h" + +#include +#include +#include +#include + +#include +#include +#include +#include + + + +unsafe{ + +int main() { + + chan c_tile_sync; + chan c_audio_frames; + + par { + + on tile[0]: { + xscope_config_io(XSCOPE_IO_BASIC); + board_dac3101_init(); + c_tile_sync <: 1; + printf("Running " APP_NAME "..\n"); + } + + + on tile[1]: { + // Force it to use xscope, never mind any config.xscope files + xscope_config_io(XSCOPE_IO_BASIC); + + // This will buffer output audio for when I2S needs it. + int32_t audio_buffer[AUDIO_BUFFER_SAMPLES][N_MICS]; + audio_ring_buffer_t output_audio_buffer = + abuff_init(N_MICS, AUDIO_BUFFER_SAMPLES, &audio_buffer[0][0]); + + // Set up the media clock + device_pll_init(); + + // Initialize the mic array + app_init(); + + // Wait until tile[0] is done initializing the DAC via I2C + unsigned ready; + c_tile_sync :> ready; + + // XC complains about parallel usage rules if we pass the + // buffer's address directly + void * unsafe oab = &output_audio_buffer; + + par { + app_decimator_task((chanend_t) c_audio_frames); + +#if (!APP_USE_PDM_RX_ISR) + app_pdm_rx_task(); +#endif + app_i2s_task( (void*) oab ); + + receive_and_buffer_audio_task( (chanend_t) c_audio_frames, + &output_audio_buffer, + N_MICS, SAMPLES_PER_FRAME, + N_MICS * SAMPLES_PER_FRAME ); + } + } + } + + return 0; +} + +} diff --git a/demos/demo_vanilla/CMakeLists.txt b/demos/demo_vanilla/CMakeLists.txt new file mode 100644 index 00000000..bcc40671 --- /dev/null +++ b/demos/demo_vanilla/CMakeLists.txt @@ -0,0 +1,46 @@ + +set(APP_NAME demo_vanilla) + +set( TARGET_XN XVF3610_Q60A.xn ) + +#********************** +# Vanilla Configuration +#********************** + +set( MCLK_FREQ 24576000 ) +set( PDM_FREQ 3072000 ) +set( SAMPLES_PER_FRAME 16 ) + + +#********************** +# includes +#********************** + +set( APP_INCLUDES "src" ) +list( APPEND APP_INCLUDES ${DEMO_COMMON_INCLUDES} ) + +#********************** +# sources +#********************** + +file( GLOB_RECURSE APP_SOURCES "src/*.c" "src/*.xc" "src/*.cpp" "src/*.S" ) + +list( APPEND APP_SOURCES ${DEMO_COMMON_SOURCES} ) + +#********************** +# create targets +#********************** + +foreach( N_MICS 1 2 ) + + set( TARG_NAME "${APP_NAME}_${N_MICS}mic" ) + + make_demo_app_target( ${TARG_NAME} "${APP_SOURCES}" "${APP_INCLUDES}" "" ) + + mic_array_vanilla_add( ${TARG_NAME} ${MCLK_FREQ} ${PDM_FREQ} + ${N_MICS} ${SAMPLES_PER_FRAME} ) + + add_dependencies( demos ${TARG_NAME} ) + +endforeach() + diff --git a/demos/demo_vanilla/XVF3610_Q60A.xn b/demos/demo_vanilla/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/demos/demo_vanilla/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demos/demo_vanilla/src/app.h b/demos/demo_vanilla/src/app.h new file mode 100644 index 00000000..67d4537e --- /dev/null +++ b/demos/demo_vanilla/src/app.h @@ -0,0 +1,15 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "app_config.h" +#include "app_common.h" +#include "mic_array.h" + +C_API_START + +MA_C_API +void app_i2s_task( void* app_context ); + +C_API_END \ No newline at end of file diff --git a/demos/demo_vanilla/src/app_config.h b/demos/demo_vanilla/src/app_config.h new file mode 100644 index 00000000..61b11510 --- /dev/null +++ b/demos/demo_vanilla/src/app_config.h @@ -0,0 +1,10 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#define AUDIO_BUFFER_SAMPLES ((unsigned)(MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME * 1.2)) +#define APP_AUDIO_PIPELINE_SAMPLE_RATE 16000 +#define APP_I2S_AUDIO_SAMPLE_RATE APP_AUDIO_PIPELINE_SAMPLE_RATE +#define MIC_ARRAY_CLK1 XS1_CLKBLK_1 +#define MIC_ARRAY_CLK2 XS1_CLKBLK_2 diff --git a/demos/demo_vanilla/src/app_i2s.c b/demos/demo_vanilla/src/app_i2s.c new file mode 100644 index 00000000..bb161bb9 --- /dev/null +++ b/demos/demo_vanilla/src/app_i2s.c @@ -0,0 +1,112 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include + +#include "app.h" +#include "i2s.h" +#include "util/audio_buffer.h" + +#include "app_config.h" + +#include +#include +#include +#include +#include +#include + +#include + +#define I2S_CLKBLK XS1_CLKBLK_3 + + +static int i2s_mclk_bclk_ratio( + const unsigned audio_clock_frequency, + const unsigned sample_rate) +{ + return audio_clock_frequency / (sample_rate * (8 * sizeof(int32_t)) * I2S_CHANS_PER_FRAME); +} + + + +I2S_CALLBACK_ATTR +void app_i2s_send(audio_ring_buffer_t* app_data, + size_t num_out, + int32_t* samples) +{ + int32_t frame[MIC_ARRAY_CONFIG_MIC_COUNT]; + abuff_frame_get(app_data, frame); + + for(int c = 0; c < num_out; c++){ + int32_t samp = frame[(MIC_ARRAY_CONFIG_MIC_COUNT==1)?0:c]; + samples[c] = samp; + } +} + + + +I2S_CALLBACK_ATTR +static +void app_i2s_init(audio_ring_buffer_t* app_data, + i2s_config_t* config) +{ + config->mode = I2S_MODE_I2S; + config->mclk_bclk_ratio = i2s_mclk_bclk_ratio(MIC_ARRAY_CONFIG_MCLK_FREQ, + APP_I2S_AUDIO_SAMPLE_RATE); +} + + + + +I2S_CALLBACK_ATTR +static +i2s_restart_t app_i2s_restart(audio_ring_buffer_t* app_data) +{ + static unsigned do_restart = 0; + i2s_restart_t res = do_restart? I2S_RESTART : I2S_NO_RESTART; + do_restart = 0; + return res; +} + + + + + +I2S_CALLBACK_ATTR +static +void app_i2s_receive(audio_ring_buffer_t* app_data, + size_t num_in, + const int32_t* samples) +{ + +} + + + +i2s_callback_group_t i2s_context = { + .init = (i2s_init_t) app_i2s_init, + .restart_check = (i2s_restart_check_t) app_i2s_restart, + .receive = (i2s_receive_t) app_i2s_receive, + .send = (i2s_send_t) app_i2s_send, + .app_data = NULL, +}; + + + +void app_i2s_task( void* app_context ) +{ + i2s_context.app_data = app_context; + + port_t p_i2s_dout[] = { I2S_DATA_IN }; + // port_t p_i2s_din[] = { I2S_DATA_IN }; + port_t p_i2s_din[0]; + + i2s_master(&i2s_context, + p_i2s_dout, 1, + p_i2s_din, 0, + PORT_I2S_BCLK, + PORT_I2S_LRCLK, + PORT_MCLK_IN_OUT, + I2S_CLKBLK); +} diff --git a/demos/demo_vanilla/src/main.xc b/demos/demo_vanilla/src/main.xc new file mode 100644 index 00000000..707714ee --- /dev/null +++ b/demos/demo_vanilla/src/main.xc @@ -0,0 +1,82 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "app_config.h" +#include "util/mips.h" +#include "device_pll_ctrl.h" + +#include "app.h" +#include "mic_array_vanilla.h" +#include "util/audio_buffer.h" + +#include +#include +#include +#include + +#include +#include +#include +#include + + + +unsafe{ + + +int main() { + + chan c_tile_sync; + chan c_audio_frames; + + par { + + on tile[0]: { + xscope_config_io(XSCOPE_IO_BASIC); + board_dac3101_init(); + c_tile_sync <: 1; + printf("Running " APP_NAME "..\n"); + } + + + on tile[1]: { + // Force it to use xscope, never mind any config.xscope files + xscope_config_io(XSCOPE_IO_BASIC); + + // Set up the media clock + device_pll_init(); + + // This ring buffer will serve as the app context. + int32_t audio_buffer[AUDIO_BUFFER_SAMPLES][MIC_ARRAY_CONFIG_MIC_COUNT]; + audio_ring_buffer_t app_context = abuff_init(MIC_ARRAY_CONFIG_MIC_COUNT, + AUDIO_BUFFER_SAMPLES, + &audio_buffer[0][0]); + + + // Wait until tile[0] is done initializing the DAC via I2C + unsigned ready; + c_tile_sync :> ready; + + ma_vanilla_init(); + + // XC complains about parallel usage rules if we pass the + // object's address directly + void * unsafe app_ctx = &app_context; + + par { + ma_vanilla_task((chanend_t) c_audio_frames); + + receive_and_buffer_audio_task((chanend_t) c_audio_frames, + &app_context, MIC_ARRAY_CONFIG_MIC_COUNT, + MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME, + MIC_ARRAY_CONFIG_MIC_COUNT * MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME); + + app_i2s_task( (void*) app_ctx ); + } + } + } + + return 0; +} + +} diff --git a/demos/measure_mips/CMakeLists.txt b/demos/measure_mips/CMakeLists.txt new file mode 100644 index 00000000..fcb15d1e --- /dev/null +++ b/demos/measure_mips/CMakeLists.txt @@ -0,0 +1,43 @@ + +set(APP_NAME measure_mips) + +set( TARGET_XN XVF3610_Q60A.xn ) + + +#********************** +# includes +#********************** + +set( APP_INCLUDES "src" ) +list( APPEND APP_INCLUDES ${DEMO_COMMON_INCLUDES} ) + +#********************** +# sources +#********************** + +file( GLOB_RECURSE APP_SOURCES "src/*.c" "src/*.xc" "src/*.cpp" "src/*.S" ) +list( APPEND APP_SOURCES ${DEMO_COMMON_SOURCES} ) + +#********************** +# create targets +#********************** + +set( NAME_MAP thread;isr ) + +foreach( N_MICS 1 2 ) + foreach( USE_ISR 1 0 ) + + list( GET NAME_MAP ${USE_ISR} tmp ) + set( TARG_NAME "${APP_NAME}_${N_MICS}mic_${tmp}" ) + + unset(TARG_FLAGS) + list( APPEND TARG_FLAGS + "-DN_MICS=${N_MICS}" + "-DAPP_USE_PDM_RX_ISR=${USE_ISR}" ) + + make_demo_app_target( ${TARG_NAME} "${APP_SOURCES}" "${APP_INCLUDES}" "${TARG_FLAGS}" ) + + add_dependencies( demos ${TARG_NAME} ) + + endforeach() +endforeach() \ No newline at end of file diff --git a/demos/measure_mips/XVF3610_Q60A.xn b/demos/measure_mips/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/demos/measure_mips/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demos/measure_mips/src/app.cpp b/demos/measure_mips/src/app.cpp new file mode 100644 index 00000000..ec0f70ba --- /dev/null +++ b/demos/measure_mips/src/app.cpp @@ -0,0 +1,74 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include + +#include "app.h" + +#include "mic_array/cpp/MicArray.hpp" +#include "mic_array/cpp/Prefab.hpp" +#include "mic_array/etc/filters_default.h" + +#define DCOE_ENABLED true + + +#if (N_MICS != 2) +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_SDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + MIC_ARRAY_CLK1); +#else +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_DDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + MIC_ARRAY_CLK1, + MIC_ARRAY_CLK2); +#endif + + +using TMicArray = mic_array::prefab::BasicMicArray< + N_MICS, SAMPLES_PER_FRAME, DCOE_ENABLED>; + +TMicArray mics = TMicArray(); + +MA_C_API +void app_init() +{ + mics.Init(); + + // Configure our clocks and ports + const unsigned mclk_div = mic_array_mclk_divider( + APP_AUDIO_CLOCK_FREQUENCY, APP_PDM_CLOCK_FREQUENCY); + + mic_array_resources_configure(&pdm_res, mclk_div); + + mics.SetPort(pdm_res.p_pdm_mics); +} + +MA_C_API +void app_pdm_rx_task() +{ + mic_array_pdm_clock_start(&pdm_res); + mics.PdmRxThreadEntry(); +} + +MA_C_API +void app_decimator_task(chanend_t c_frames_out) +{ + mics.SetOutputChannel(c_frames_out); + +#if APP_USE_PDM_RX_ISR + // Start the PDM clock + mic_array_pdm_clock_start(&pdm_res); + + mics.InstallPdmRxISR(); + mics.UnmaskPdmRxISR(); +#endif + mics.ThreadEntry(); +} + + diff --git a/demos/measure_mips/src/app.h b/demos/measure_mips/src/app.h new file mode 100644 index 00000000..cf5f0461 --- /dev/null +++ b/demos/measure_mips/src/app.h @@ -0,0 +1,21 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "app_config.h" +#include "app_common.h" +#include "mic_array.h" + +C_API_START + +MA_C_API +void app_init(); + +MA_C_API +void app_pdm_rx_task(); + +MA_C_API +void app_decimator_task(chanend_t c_frames_out); + +C_API_END \ No newline at end of file diff --git a/demos/measure_mips/src/app_config.h b/demos/measure_mips/src/app_config.h new file mode 100644 index 00000000..87a56d3c --- /dev/null +++ b/demos/measure_mips/src/app_config.h @@ -0,0 +1,21 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#ifndef N_MICS +# error "N_MICS not defined." +#endif + +#ifndef APP_USE_PDM_RX_ISR +# error "APP_USE_PDM_RX_ISR not defined." +#endif + +#define SAMPLES_PER_FRAME 16 + +#define APP_AUDIO_CLOCK_FREQUENCY 24576000 +#define APP_PDM_CLOCK_FREQUENCY 3072000 +#define APP_I2S_AUDIO_SAMPLE_RATE 16000 + +#define MIC_ARRAY_CLK1 XS1_CLKBLK_1 +#define MIC_ARRAY_CLK2 XS1_CLKBLK_2 diff --git a/demos/measure_mips/src/main.xc b/demos/measure_mips/src/main.xc new file mode 100644 index 00000000..2816409e --- /dev/null +++ b/demos/measure_mips/src/main.xc @@ -0,0 +1,84 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "app_config.h" +#include "util/mips.h" +#include "device_pll_ctrl.h" +#include "mic_array/frame_transfer.h" + +#include "app.h" +#include "app_common.h" + +#include +#include +#include +#include + +#include +#include +#include +#include + + + +unsafe{ + +int main() { + + chan c_audio_frames; + + par { + + on tile[0]: { + xscope_config_io(XSCOPE_IO_BASIC); + printf("Running " APP_NAME "..\n"); + + eat_audio_frames_task((chanend_t) c_audio_frames, + N_MICS*SAMPLES_PER_FRAME); + } + + + on tile[1]: { + + // Force it to use xscope, never mind any config.xscope files + xscope_config_io(XSCOPE_IO_BASIC); + + // Set up the media clocks + device_pll_init(); + + // Initialize the mic array + app_init(); + + par { +#if (!APP_USE_PDM_RX_ISR) + app_pdm_rx_task(); +#endif + + app_decimator_task((chanend_t) c_audio_frames); + + // The burn_mips() and the count_mips() should all consume as many MIPS as they're offered. And + // they should all get the SAME number of MIPS. + // print_mips() uses almost no MIPS -- we can assume it's zero. + // So, with 600 MIPS total, 6 cores using X MIPS, 1 core using none and the mic array using Y MIPS... + // 600 = 6*X + Y --> Y = 600 - 6*X + +// If we're using the ISR we'll use 5 burn_mips(). Otherwise just 4. Either way the printed MIPS will +// be all the mic array work. +#if APP_USE_PDM_RX_ISR + burn_mips(); +#endif + + burn_mips(); + burn_mips(); + burn_mips(); + burn_mips(); + count_mips(); + print_mips(APP_USE_PDM_RX_ISR); + } + } + } + + return 0; +} + +} diff --git a/doc/.gitignore b/doc/.gitignore new file mode 100644 index 00000000..a6292b8b --- /dev/null +++ b/doc/.gitignore @@ -0,0 +1,3 @@ + +_doxygen/ +_build/ \ No newline at end of file diff --git a/doc/Doxyfile.inc b/doc/Doxyfile.inc new file mode 100644 index 00000000..e092302e --- /dev/null +++ b/doc/Doxyfile.inc @@ -0,0 +1,8 @@ +# This file provides overrides to the Doxyfile configuration + +PROJECT_NAME = lib_mic_array +PROJECT_BRIEF = "PDM Mic Array library for the XMOS XS3 architecture" + +INPUT = ../lib_mic_array/api ../etc/vanilla ../doc/programming_guide/src + +PREDEFINED = MA_C_API= C_API_START= C_API_END= __DOXYGEN__=1 diff --git a/doc/README.rst b/doc/README.rst new file mode 100644 index 00000000..c58b21b1 --- /dev/null +++ b/doc/README.rst @@ -0,0 +1,84 @@ +###################### +Building Documentation +###################### + +Instructions are given below to build the documentation. The recommended method is using Docker, +however, alternative instructions are provided in case using Docker in not an option. + +To develop the content of this repository, it is recommended to launch a `sphinx-autobuild` +server as per the instructions below. Once started, point a web-browser at +http://127.0.0.1:8000. If running the server within a VM, remember to configure +port forwarding. + +You can now edit the .rst documentation, and your web-browser content will automatically +update. + +************ +Using Docker +************ + +============= +Prerequisites +============= + +Install `Docker `_. + +Pull the docker container: + +.. code-block:: console + + $ docker pull ghcr.io/xmos/doc_builder:main + +======== +Building +======== + +To build the documentation, run the following command in the root of the repository: + +.. code-block:: console + + $ docker run --rm -t -u "$(id -u):$(id -g)" -v $(pwd):/build -e REPO:/build -e DOXYGEN_INCLUDE=/build/doc/Doxyfile.inc ghcr.io/xmos/doc_builder:main + +******************** +Without Using Docker +******************** + +============= +Prerequisites +============= + +Install `Doxygen `_. + +Install the required Python packages: + +.. code-block:: console + + $ pip install -r requirements.txt + +======== +Building +======== + +Build documentation: + +.. code-block:: console + + $ make html + +Launch sphinx-autobuild server: + +.. code-block:: console + + $ make livehtml + +Clean documentation: + +.. code-block:: console + + $ make clean + +Clean and build documentation with link check: + +.. code-block:: console + + $ make clean html linkcheck SPHINXOPTS="-W --keep-going" diff --git a/doc/doc_excludes.txt b/doc/doc_excludes.txt new file mode 100644 index 00000000..c8bb370e --- /dev/null +++ b/doc/doc_excludes.txt @@ -0,0 +1,3 @@ +/build/*build*/**/*.rst +/build/*build*/**/*.md +**/disclaimer.rst diff --git a/doc/programming_guide/index.rst b/doc/programming_guide/index.rst new file mode 100644 index 00000000..50902389 --- /dev/null +++ b/doc/programming_guide/index.rst @@ -0,0 +1,19 @@ +.. lib_mic_array documentation master file + +Mic Array Library +================= + +.. toctree:: + :maxdepth: 1 + :caption: Contents: + + src/introduction + src/overview + src/getting_started + src/decimator_stages + src/sample_filters + src/software_structure + src/resource_usage + src/vanilla_api + + src/reference/api_index diff --git a/doc/programming_guide/src/dcoe_freq_response.png b/doc/programming_guide/src/dcoe_freq_response.png new file mode 100644 index 00000000..cf620d28 Binary files /dev/null and b/doc/programming_guide/src/dcoe_freq_response.png differ diff --git a/doc/programming_guide/src/decimator_stages.rst b/doc/programming_guide/src/decimator_stages.rst new file mode 100644 index 00000000..73093c41 --- /dev/null +++ b/doc/programming_guide/src/decimator_stages.rst @@ -0,0 +1,148 @@ +.. _decimator_stages: + +Decimator Stages +================ + +The mic array unit provided by this library uses a two-stage decimation process +to convert a high sample rate stream of (1-bit) PDM samples into a lower sample +rate stream of (32-bit) PCM samples. + +Below is a simplified model of the mic array unit. + +.. figure:: diagrams/decimator_stages.drawio.png + :align: center + :scale: 100 % + :alt: Simplified Decimator Model + +The first stage filter is a decimating FIR filter with a fixed tap count +(``S1_TAP_COUNT``) of ``256`` and a fixed decimation factor (``S1_DEC_FACTOR``) +of ``32``. + +The second stage decimator is a fully configurable FIR filter with tap count +``S2_TAP_COUNT`` and a decimation factor of ``S2_DEC_FACTOR`` (this can be +``1``). + +Decimator Stage 1 +----------------- + +For the first stage decimating FIR filter, the actual filter coefficients used +are configurable, so an application is free to use a custom first stage filter, +as long as the tap count is ``256``. This library also provides coefficients for +the first stage filter, whose filter characteristics are adequate for most +applications. + +Filter Implementation (Stage 1) +******************************* + +The input to the first stage decimator (here called "Stream A") is a stream of +1-bit PDM samples with a sample rate of ``PDM_FREQ``. Rather than each PDM +sample representing a value of ``0`` or ``1``, each PDM sample represents a +value of either ``+1`` or ``-1``. Specifically, on-chip and in-memory, a bit +value of ``0`` represents ``+1`` and a bit value of ``1`` represents ``-1``. + +The output from the first stage decimator, Stream B, is a stream of 32-bit PCM +samples with a sample rate of ``PDM_FREQ/S1_DEC_FACTOR = PDM_FREQ/32``. For +example, if ``PDM_FREQ`` is 3.072 MHz, then Stream B's sample rate is 96.0 kHz. + +The first stage filter is structured to make optimal use of the XCore XS3 vector +processing unit (VPU), which can compute the dot product of a pair of +256-element 1-bit vectors in a single cycle. The first stage uses 256 16-bit +coefficients for its filter taps. + +The signature of the filter function is + +.. code-block:: c + + int32_t fir_1x16_bit(uint32_t signal[8], uint32_t coeff_1[]); + + +Each time 32 PDM samples (1 word) become available for an audio channel, those +samples are shifted into the 8-word (256-bit) filter state, and a call to +``fir_1x16_bit`` results in 1 Stream B sample element for that channel. + +The actual implementation for the first stage filter can be found in +``src/fir_1x16_bit.S``. Additional usage details can be found in +``api/etc/fir_1x16_bit.h``. + +Note that the 256 16-bit filter coefficients are **not** stored in memory as a +standard coefficient array (i.e. ``int16_t filter[256] = {b[0], b[1], ... };``). +Rather, in order to take advantage of the VPU, the coefficients must be +rearranged bit-by-bit into a block form suitable for VPU processing. See the +section below on filter conversion if supplying a custom filter for stage 1. + +Provided Filter (Stage 1) +************************* + +This library provides filter coefficients that may be used with the first stage +decimator. These coefficients are available in your application through the +header ``mic_array/etc/filters_default.h`` as ``stage1_coef``. + +Filter Characteristics (Stage 1) +'''''''''''''''''''''''''''''''' + +The plot below indicates the frequency response of the provided first stage +decimation filter. + +.. image:: stage1_freq_response.png + + +Filter Conversion Script +************************ + +Taking a set of floating-point coefficients, quantizing them into 16-bit +coefficients and 'boggling' them into the correct memory layout can be a tricky +business. To simplify this process, this library provides a Python (3) script +which does this process for you. + +The script can be found in this repository at ``script/stage1.py``. + +.. todo:: + + Generalize script. Currently looks for coefficients in a specific ``.pkl`` + file. + + +Decimator Stage 2 +----------------- + +An application is free to supply its own second stage filter. This library also +provides a second stage filter whose characteristics are adequate for many or +most applications. + +Filter Implementation (Stage 2) +******************************* + +The input to the second stage decimator (here called "Stream B") is the stream +of 32-bit PCM samples emitted from the first stage decimator with a sample rate +of ``PDM_FREQ/32``. + +The output from the second stage decimator, Stream C, is a stream of 32-bit PCM +samples with a sample rate of ``PDM_FREQ/(32*S2_DEC_FACTOR)``. For example, if +``PDM_FREQ`` is 3.072 MHz, and ``S2_DEC_FACTOR`` is ``6``, then Stream C's +sample rate (the sample rate received by the main application code) is + + 3.072 MHz / (32*6) = 16 kHz + +The second stage filter uses the 32-bit FIR filter implementation from +`lib_xcore_math `_. See +``xs3_filter_fir_s32()`` in that library for more implementation details. + +Provided Filter (Stage 2) +************************* + +This library provides a filter suitable for the second stage decimator. It is +available in your application through the header +``mic_array/etc/filters_default.h``. + +For the provided filter ``S2_TAP_COUNT = 65``, and ``S2_DEC_FACTOR = 6``. + +Filter Characteristics (Stage 2) +'''''''''''''''''''''''''''''''' + +The plot below indicates the frequency response of the provided second stage +decimation filter. + +.. image:: stage2_freq_response.png + + + diff --git a/doc/programming_guide/src/diagrams/decimator_stages.drawio b/doc/programming_guide/src/diagrams/decimator_stages.drawio new file mode 100644 index 00000000..ffb095c7 --- /dev/null +++ b/doc/programming_guide/src/diagrams/decimator_stages.drawio @@ -0,0 +1 @@ +7Vprb9s2FP01ApICNvS29NHPbVi6pfGwtZ8CWqJlrrLoUnRs59fvUqLesmsnShMsNZCEvHzfc3h4SUcxxuv9LwxtVh+pj0NFV/29YkwUXXcdF34LwyE1WI6WGgJG/NRUMszJI5ZGVVq3xMdxpSKnNORkUzV6NIqwxys2xBjdVastaVgddYMC3DDMPRQ2rf8Qn6+kVVPVouBXTIKVHNqxZMECeV8DRreRHE/RjWXySYvXKOtL1o9XyKe7ksmYKsaYUcrT1Ho/xqFwbea2tN3sSGk+b4Yjfk4DU/Om9O/Jt9vD2n3c//6vOb0xe2baywMKtzhbRjJZfsgclCwRi05UxRjtVoTj+QZ5onQHjADbiq9DyGmQjDmjX/GYhpQlrQ3NcN3JCEqWNOIztCah4MmQESTm9gd9QPDnJnVvUqfU1rTNgekKOwnDzB7RCOcDZYiZYAlCFMdyligkQQRpD3yDodXIR/EqWYOYpFwzZhzvjzpTyyEC5mO6xpwdoIpskKOasV7ugl1BISsjyqrEnrwdkrQN8q4L6CAh0bsASb2B5JwL6usqrMQOhXsXDFKBSE2wR4CgJAqaZbPf7qDRjITCc8fJoD2BDECFoTrokAxgHznTga52g6pRQ1XLRKoEq6a3wGq/FKpGA9VbyngDFtCWjUjCUjk48w6EEkWBKP0eRiFecrlpmFyPemrHtSLyDDQ7QG3w1kCzG6DJ/UabGwqWzRvOlR5vAaGEnPCoPE41K8vLjkW58CmBc24otXBNfD9hREMcXxk/07QqANot+Kkt+Jkvhd/gqJTqZbkswWh/29LETJmPWc9LHTVMOmFXvV7Zfp14LWtxWpE7HeIdC3t+Fr8ZjdCa53UDE+xDpCqzzf3/fD2uq8cZoEy0SRpt4T3hn+VMRPqLODj6lsxN9vIcSTIHmQnRAoe3NCac0IoAZVJ1U6twXLKOilvqROG501QBR9Mt8/D3z16OWID5iXp6O/UYDmE/P1Tn0cYj2fSWEphhEWFabt8tf8wqgw23b1uOq6qabpuienWAdHWyz/KtoDaModt9y1aLj10dxlT7ulvtOnVIo+shY+hQqrYRFeLGRsk99Iy904yKhq2bJ+FTddeczySGY/KIFkl/gr1yPdC5NVKsSW0PqS91jsp7r5yIkl8gyow+oTBHJVHta5ZTPXjliE8lblaFLpcx5i8CvNsAfnRSNXG4oLtpYRglBihYUUYeAQok6IEjfyheEgQtxCWSeFXOeFv2kF+Aq9dhaCoZ4CSSDPF3Jd+VRKvnS/Qs+TxRooFS7PC5nCm1EtmiWZLL2nUou/qZsjtop3f5Bt5yoGe2Z6qzZdYCinoweq7+Wm61I7fWz8Vi2z6Madfma1UeiyCR9tjpdtVbdHqzaWzYd315dbS3FpnqzTfB8U+R/Z+J7ODc2NZ4TZW16087SdBbhMSO8zTRHQyqsbVz0SgdSfKg/thowrD2D1Blq7G/Fd1Ga6Gt0SLeJERTW0xzzjBaQ0I8OvTg56qlktZbEH4NidvJR0FEKA9xLDo02/qsm6DV/exu+um8Gf00vR2TQBr4GGOv+ZXChfwaZfwy9JxN43PYdFXQZ2bo16/vlHdi6hD7cRfYQ+MPc/1+Mh3fz4bjv/68u27jQnnWz3uVLwcRplJ9ihcH9495ii8Hxk9+aesgpNWN2sGW3WnKQUNbSJud9heEtJAtvkFPT8jivxSM6X8= \ No newline at end of file diff --git a/doc/programming_guide/src/diagrams/decimator_stages.drawio.png b/doc/programming_guide/src/diagrams/decimator_stages.drawio.png new file mode 100644 index 00000000..e1861c51 Binary files /dev/null and b/doc/programming_guide/src/diagrams/decimator_stages.drawio.png differ diff --git a/doc/programming_guide/src/diagrams/high_level_process.drawio b/doc/programming_guide/src/diagrams/high_level_process.drawio new file mode 100644 index 00000000..fa09407e --- /dev/null +++ b/doc/programming_guide/src/diagrams/high_level_process.drawio @@ -0,0 +1 @@ +7Vptc6o4FP41flwnEED4WF9678y2e512Zrf3Y4So2QJxQ6zaX78nEBCIWmu17UzLF5OTV85znnOSgx08SNY/BFnMb3lE446NonUHDzu2bTnYgR8l2RQS38GFYCZYpDttBffsmWoh0tIli2jW6Cg5jyVbNIUhT1MayoaMCMFXzW5THjdXXZAZNQT3IYlN6T8sknMttRDaNvykbDbXS/uubpiQ8HEm+DLV63VsPM2fojkh5Vy6fzYnEV/VRHjUwQPBuSxKyXpAY6XbUm3FuOs9rdW+BU3lMQMcKxzxv4f/jTdJ8Lz+819ndOP8ocF7IvGSlq+Rb1ZuSgXlr0jVJKiD+6s5k/R+QULVugKTANlcJjHULChmUvBHOuAxF/lobOEgGPahZcpTeU0SFis7uRKMqL39xZ8I/NwU6s371MY6ntNzAiVncVzKU57SaqESMQcks5hkmd4lidkshXIIuqEwqh+RbJ6/g9qkqTmtzCcqJF3XRFqTPyhPqBQb6KJbbU+jqq0etplXV1sTcrDuMq9ZD/ZL09VmO6um3kIHBY3eK5C0DSTHUXL3cABO6wQ4Acwr1DsjnCDv+6Oejc6Di2O5DVys0s3UgLHsHcCUeJ4dF2ziMrwFwS0Ls47txUpREwGlmSpJbsoeBr/uRjBizIU04ASvslBF0JoEEO7ARZJ0plpfwjamU6npIrQe0CGu7UTyDVZwBrR76JOB7RlgA8xXQpCNARy8ojR0qxW+A4MacEqhOo6Cteu6nli1K/0xCHBX2gkmLIpygzC84gfD59hNsrrYhA/tgM+5FHw9A74hDRlEcnj7L+5Hg4+mlm9gc0+SBaBho2sWK3v+2ghVzvDDEAoMhH4t5WIJMQv9JCm4oK8OEXY/GiLLPCUamNAI7ke6agaft58F2qHrCFCG1rA449M1kw96J6r8Wx1auq6uDdf6DJNXNroSkwmNxzxjkvFG9Cvj5E2rw/54uTey7jWWjC9FSF8+HkoiZlQe6KdxUuAcND1BYyLZU/Nyu8uO9NAxZ6ms3WvcoBvUH6cZBnDQ9Vw/QMiyPUd1by5QvK6es34XbS2Dba/remj7eM1lHNS1g+bUhYaMqfXhquq2UB0ygyiVht7AnX0n+SIOZTuJlNtWk0HHW5WgGXsmk3w+Zcn63WByt99xhy0+obMf6A67kLYbrFI0esedeppjl3tEXcv1W8eMonaqEZdd+HSaUXkRIzCDXN0IoNCPefi42xhKr0rjCV+NtoJ+LoCGORfsGeAhymRoGl2p/JYyFZXaYGHTjsKleKrSMs0kDQzVVuHnLhvuho36uVw4Ot6FX+fPiS4cLFJsqkGqUhulqtthea0cd7pbto90y70j3XIt4rs7An4pe6P3dp3Whbh9UzrWP7tBc6KgNc+rnfHuZTzU2q/fSGFCoZjxrBQuD1w1ChcXCKDPlsff9H2Bvl3k2O9AYTXJmAoGqKtg+UZa+0fSOvhctG4lmw06Hk3r1kS49z68xhgd3JfXSgS1+l/ID5T3OSPb8+0IXuEI0ClOAL3OCZxO+N6RhPc/FeFxiz/Vx9JX37PaE10okFeZjXId9zDhS4JX/b33ILyZ/KiubkhleNG1IMmei9w350/k/Onc/VxBGFutmGafyEm7HRz9C3Gy1wqq78IxM0lSfr4czEmaqj+PHPPNc8DTbJmojDGSc0FJZJDyS3/49FsmdMHEMlS3/1EpzGT7RyA8+h8= \ No newline at end of file diff --git a/doc/programming_guide/src/diagrams/high_level_process.drawio.png b/doc/programming_guide/src/diagrams/high_level_process.drawio.png new file mode 100644 index 00000000..55abbeb3 Binary files /dev/null and b/doc/programming_guide/src/diagrams/high_level_process.drawio.png differ diff --git a/doc/programming_guide/src/getting_started.rst b/doc/programming_guide/src/getting_started.rst new file mode 100644 index 00000000..07af0284 --- /dev/null +++ b/doc/programming_guide/src/getting_started.rst @@ -0,0 +1,355 @@ +.. _getting_started: + +Getting Started +=============== + +There are three models for how the mic array unit can be included in an +application. The details of how to allocate, initialize and start the mic array +will depend on the chosen model. + +In order of increasing complexity, these are: + +* Vanilla Model - The simplest way to include the mic array. It is usually + sufficient but offers comparatively little flexibility with respect to + configuration and run-time control. Using this model (mostly) means modifying + an application's build scripts. +* Prefab Model - This model involves a little more effort from the application + developer, including writing a couple C++ wrapper functions, but gives the + application access to any of the defined prefab mic array components. +* General Model - Any other case. This is necessary if an application wishes to + use a customized mic array component. + +The vanilla and prefab models for integrating the mic array into your +application will be discussed in more detail below. The general model may +involve customizing or extending the classes in ``lib_mic_array`` and is beyond +the scope of this introduction. + +Whichever model is chosen, the first step to integrate a mic array unit into an +application is to *identify the required hardware resources*. + + +Identify Resources +------------------ + +The key hardware resources to be identified are the *ports* and *clock blocks* +that will be used by the mic array unit. The ports correspond to the physical +pins on which clocks and sample data will be signaled. Clock blocks are a type +of hardware resource which can be attached to ports to coordinate the +presentation and capture of signals on physical pins. + +Clock Blocks +************ + +While clock blocks may be more abstract than ports, their implications for this +library are actually simpler. First, the mic array unit will need a way of +taking the audio master clock and dividing it to produce a PDM sample clock. +This can be accomplished with a clock block. This will be the clock block which +the API documentation refers to as "Clock A". + +Second, if (and only if) the PDM microphones are being used in a Dual Data Rate +(DDR) configuration a second clock block will be required. In a DDR +configuration 2 microphones share a physical pin for output sample data, where +one signals on the rising edge of the PDM clock and the other signals on the +falling edge. The second clock block required in a DDR configuration is referred +to as "Clock B" in the API documentation. + +Each tile on an xcore.ai device has 5 clock blocks available. In code, a clock +block is identified by its resource ID, which are given as the preprocessor +macros ``XS1_CLKBLK_1`` through ``XS1_CLKBLK_5``. + +Unlike ports, which are tied to specific physical pins, clock blocks are +fungible. Your application is free to use any clock block that has not already +been allocated for another purpose. The vanilla component model defaults to +using ``XS1_CLKBLK_1`` and ``XS1_CLKBLK_2``. + +Ports +***** + +Three ports are needed for the mic array component. As mentioned above, ports +are physically tied to specific device pins, and so the correct ports must be +identified for correct behavior. + +Note that while ports are physically tied to specific pins, this is *not* a +1-to-1 mapping. Each port has a port width (measured in bits) which is the +number of pins which comprise the port. Further, the pin mappings for different +ports *overlap*, with a single pin potentially belonging to multiple ports. When +identifying the needed ports, take care that both the pin map (see the +documentation for your xcore.ai package) and port width are correct. + +The first port needed is a 1-bit port on which the audio master clock is +received. In the documentation, this is usually referred to as ``p_mclk``. + +The second port needed is a 1-bit port on which the PDM clock will be signaled +to the PDM mics. This port is referred to as ``p_pdm_clk``. + +The third port is that on which the PDM data is received. In an SDR +configuration, the width of this port must be greater than or equal to the +number of microphones. In a DDR configuration, twice this port width must be +greater than or equal to the number of microphones. This port is referred to as +``p_pdm_mics``. + +XCore applications are typically compiled with an "XN" file (with a ".xn" file +extension). An XN file is an XML document which describes some information about +the device package as well as some other helpful board-related information. The +identification of your ports may have already been done for you in your XN file. +Following is a snippet from an XN file with mappings for the three ports +described above: + +.. code-block:: xml + + ... + + + + + + + + + + + + ... + + +The first 3 ports listed, ``PORT_PDM_CLK``, ``PORT_PDM_DATA`` and +``PORT_MCLK_IN_OUT`` are respectively ``p_pdm_clk``, ``p_pdm_mics`` and +``p_mclk``. The value in the ``Location`` attribute (e.g. ``XS1_PORT_1G``) is +the port name as you will find it in your package documentation. + +In this case, either ``PORT_PDM_CLK`` or ``XS1_PORT_1G`` can be used in code to +identify this port. + +Declaring Resources +******************* + +Once the ports and clock blocks to be used have been indentified, these +resources can be represented in code using a ``pdm_rx_resources_t`` struct. The +following is an example of declaring resources in a DDR configuration. See +:c:struct:`pdm_rx_resources_t`, :c:func:`PDM_RX_RESOURCES_SDR()` and +:c:func:`PDM_RX_RESOURCES_DDR()` for more details. + +.. code-block:: c + + pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_DDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + XS1_CLKBLK_1, + XS1_CLKBLK_2); + + +Note that this is not necessary in applications using the vanilla model. + +Other Resources +*************** + +In addition to ports and clock blocks, there are also several other hardware +resource types used by ``lib_mic_array`` which are worth considering. Running +out of any of these will preclude the mic array from running correctly (if at +all) + +* Threads - At least one hardware thread is required to run the mic array + component. +* Compute - The mic array unit will require a fixed number of MIPS (millions of + instructions per second) to perform the required processing. The exact + requirement will depend on the configuration used. +* Memory - The mic array requires a modest amount of memory for code and data. + (see :ref:`resource_usage`). +* Chanends - At least 4 chanends must be available for signaling between + threads/sub-components. + + +Vanilla Model +------------- + +Mic array configuration with the vanilla model is achieved mostly through the +application's build system configuration. + +In the ``/etc/vanilla`` directory of the ``lib_mic_array`` repository are a +source and header file which are not compiled with (or on the include path) of +the library. Configuring the mic array using the vanilla model means adding +those files to your *application*'s build (*not* the library target), and +defining several compile options which tell it how to behave. + +Vanilla - CMake Macro +********************* + +To simplify this further, a CMake macro called ``mic_array_vanilla_add()`` has +been included with the build system. + +``mic_array_vanilla_add()`` takes several arguments: + +* ``TARGET_NAME`` - The name of the CMake application target that the vanilla + mode source should be added to. +* ``MCLK_FREQ`` - The frequency of the master audio clock, in Hz. +* ``PDM_FREQ`` - The desired frequency of the PDM clock, in Hz. +* ``MIC_COUNT`` - The number of microphone channels to be captured. +* ``SAMPLES_PER_FRAME`` - The size of the audio frames produced by the mic array + unit (frames will be 2 dimensional arrays with shape + ``(MIC_COUNT,SAMPLES_PER_FRAME)``). + +Vanilla - Optional Configuration +******************************** + +Though not exposed by the ``mic_array_vanilla_add()`` macro, several additional +configuration options are available when using the vanilla model. These are all +configured by adding defines to the application target. + +Vanilla - Initializing and Starting +*********************************** + +Once the configuration options have been chosen, initializing and starting the +mic array at run-time is easily achieved. Two function calls are necessary, both +are included through ``mic_array_vanilla.h`` (which was added to your include +path through your build configuration). + +First, during application initialization, the function +:c:func:`ma_vanilla_init()`, which takes no arguments, must be called. This will +configure the hardware resources and install the PDM rx service as an ISR, but +will not actually start any threads or PDM capture. + +Once any remaining application initialization is complete, PDM capture and +processing is started by calling :c:func:`ma_vanilla_task()`. +``ma_vanilla_task()`` is a blocking call which takes a single argument which is +the chanend that will be used to transmit audio frames to subsequent stages of +the processing pipeline. Usually the call to ``ma_vanilla_task()`` will be +placed directly in a ``par {...}`` block along with other threads to be started +on the tile. + +.. note:: + + Both ``ma_vanilla_init()`` and ``ma_vanilla_task()`` must be called from the + core which will host the decimation thread. + +Prefab Model +------------ + +The ``lib_mic_array`` library has a C++ namespace ``mic_array::prefab`` which +contains class templates for typical mic array setups using common +sub-components. The templates in the ``mic_array::prefab`` namespace hide most +of the complexity (and unneeded flexibility) from the application author, so +they can focus only on pieces they care about. + +.. note:: + + As of version 5.0.1, only one prefab class template, + :cpp:class:`BasicMicArray `, has been + defined. + +To configure the mic array using a prefab, you will need to add a C++ source +file to your application. NB: This will end up looking a lot like the contents +of ``mic_array_vanilla.cpp`` when you are through. + +Prefab - Declare Resources +************************** + +The example in this section will use ``2`` microphones in a DDR configuration +with DC offset elimination enabled, and using 128-sample frames. The resource +IDs used may differ than those required for your application. + +``pdm_res`` will be used to identify the ports and clocks which will be +configured for PDM capture. + +Within a C++ source file: + +.. code-block:: cpp + + #include "mic_array/mic_array.h" + ... + #define MIC_COUNT 2 // 2 mics + #define DCOE_ENABLE true // DCOE on + #define FRAME_SIZE 128 // 128 samples per frame + ... + pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_DDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + MIC_ARRAY_CLK1, + MIC_ARRAY_CLK2); + ... + + +Prefab - Allocate MicArray +************************** + +The C++ class template :cpp:class:`MicArray ` is central to +the mic array unit in this library. The class templates defined in the +``mic_array::prefab`` namespace each derive from ``mic_array::MicArray``. + +Define and allocate the specific implementation of ``MicArray`` to be used. + +.. code-block:: c++ + + ... + // Using the full name of the class could become cumbersome. Using an alias. + using TMicArray = mic_array::prefab::BasicMicArray< + MIC_COUNT, FRAME_SIZE, DCOE_ENABLED> + // Allocate mic array + TMicArray mics = TMicArray(); + ... + + +Now the mic array unit has been defined and allocated. The template parameters +supplied (e.g. `MIC_COUNT` and `FRAME_SIZE`) are used to calculate the size of +any data buffers required by the mic array, and so the ``mics`` object is +self-contained, with all required buffers being statically allocated. +Additionally, class templates will ultimately allow unused features to be +optimized out at build time. For example, if DCOE is disabled, it will be +optimized out at build time so that at run time it won't even need to check +whether DCOE is enabled. + +Prefab - Init and Start Functions +********************************* + +Now a couple functions need to be implemented in your C++ file. In most cases +these functions will need to be callable from C or XC, and so they should not be +static, and they should be decorated with ``extern "C"`` (or the ``MA_C_API`` +preprocessor macro provided by the library). + +First, a function which initializes the ``MicArray`` object and configures the +port and clock block resources. The documentation for +:cpp:class:`BasicMicArray ` indicates any +parts of the ``MicArray`` object that need to be initialized. + +.. code-block:: c++ + + #define MCLK_FREQ 24576000 + #define PDM_FREQ 3072000 + ... + MA_C_API + void app_init() { + // Configure clocks and ports + const unsigned mclk_div = mic_array_mclk_divider(MCLK_FREQ, PDM_FREQ); + mic_array_resources_configure(&pdm_res, mclk_div); + + // Initialize the PDM rx service + mics.PdmRx.Init(pdm_res.p_pdm_mics); + } + ... + + +``app_init()`` can be called from an XC ``main()`` during initialization. + +Assuming the PDM rx service is to be run as an ISR, a second function is used to +actually start the mic array unit. This starts the PDM clock, install the ISR +and enter the decimator thread's main loop. + +.. code-block:: c++ + + MA_C_API + void app_mic_array_task(chanend_t c_audio_frames) { + mics.SetOutputChannel(c_audio_frames); + + // Start the PDM clock + mic_array_pdm_clock_start(&pdm_res); + + mics.InstallPdmRxISR(); + mics.UnmaskPdmRxISR(); + + mics.ThreadEntry(); + } + + +Now a call to ``app_mic_array_task()`` with the channel to send frames on can be +placed inside a ``par {...}`` block to spawn the thread. diff --git a/doc/programming_guide/src/introduction.rst b/doc/programming_guide/src/introduction.rst new file mode 100644 index 00000000..6b755f76 --- /dev/null +++ b/doc/programming_guide/src/introduction.rst @@ -0,0 +1,20 @@ + +Introduction +============ + +``lib_mic_array`` is a library for interfacing with one or more PDM microphones +on an XMOS device. + +Version 5.0 of this library has been redesigned from scratch to make efficient +usage of the XMOS XS3 architecture. + +See :ref:`getting_started` to get going. + +.. note:: + + Version 5.0 does not currently support XS2 or XS1 devices. + + +Find the latest version of ``lib_mic_array`` on `GitHub +`_. + diff --git a/doc/programming_guide/src/mic_array_diagrams.drawio b/doc/programming_guide/src/mic_array_diagrams.drawio new file mode 100644 index 00000000..2a4890f1 --- /dev/null +++ b/doc/programming_guide/src/mic_array_diagrams.drawio @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/doc/programming_guide/src/overview.rst b/doc/programming_guide/src/overview.rst new file mode 100644 index 00000000..e7a6a4c4 --- /dev/null +++ b/doc/programming_guide/src/overview.rst @@ -0,0 +1,167 @@ + + +Overview +======== + +``lib_mic_array`` is a library for capturing and processing PDM microphone data +on xcore.ai devices. + +PDM microphones are a kind of 'digital microphone' which captures audio data as +a stream of 1-bit samples at a very high sample rate. The high sample rate PDM +stream is captured by the device, filtered and decimated to a 32-bit PCM audio +stream. + +Capabilities +------------ + +* Both SDR (1 mic per pin) and DDR (2 mics per pin) microphone configurations + are supported +* Configurable clock divider allows user-selectable PDM sample clock frequency + (3.072 MHz typical) +* Configurable two-stage decimating FIR filter + + * First stage has fixed tap count of 256 and decimation factor of 32 + * Second stage has fully configurable tap count and decimation factor + * Custom filter coefficients can be used for either stage + * Reference filter with total decimation factor of 192 is provided (16 kHz + output sample rate w/ 3.072 MHz PDM clock) + +* Supports 1-, 4- and 8-bit ports. +* Supports 1 to 16 microphones + + * Includes ability to capture samples on a subset of a port's pins (e.g. 3 PDM + microphones may be used with a 4- or 8-bit port) + * Also supports microphone channel index remapping + +* Optional DC offset elimination filter +* Sample framing with user selectable frame size (down to single samples) +* Most configurations require only a single hardware thread + + +.. raw:: latex + + \newpage + +High-Level Process View +----------------------- + +This section gives a brief overview of the steps to process a PDM audio stream +into a PCM audio stream. This section is concerned with the steady state +behavior and does not describe any necessary initialization steps. + + +.. figure:: diagrams/high_level_process.drawio.png + :align: center + :scale: 100 % + :alt: Mic Array High Level Process + + +Execution Contexts +****************** + +The mic array unit uses two different execution contexts. The first is the PDM +rx service ("PDM rx"), which is responsible for reading PDM samples from the +physical port, and has relatively little work to do, but also has a strict +real-time constraint on reading port data in a timely manner. The second is the +decimation thread, which is where all processing other than PDM capture is +performed. + +This two-context model relaxes the need for tight coupling and synchronization +between PDM rx and the decimation thread, allowing significant flexibility in +how samples are processed in the decimation thread. + +PDM rx is typically run within an interrupt on the same hardware core as the +decimation thread, but it can also be run as a separate thread in cases where +many channels result in a high processing load. + +Step 1: PDM Capture +******************* + +The PDM data signal is captured by the xcore.ai device's port hardware. The port +receiving the PDM signals buffers the received samples. Each time the port +buffer is filled, PDM rx reads the received samples. + +Samples are collected word-by-word and assembled into blocks. Each time a block +has been filled, the block is transferred to the decimation thread where all +remaining mic array processing takes place. + +The size of PDM data blocks varies depending upon the configured number of +microphone channels and the configured second stage decimator's decimation +factor. Each PDM data block will contain exactly enough PDM samples to produce +one new mic array (multi-channel) output sample. + +Step 2: First Stage Decimation +****************************** + +The conversion from the high-sample-rate PDM stream to lower-sample-rate PCM +stream involves two stages of decimating filters. After the decimation thread +receives a block of PDM samples, the samples are filtered by the first stage +decimator. + +The first stage decimator has a fixed decimation factor of ``32`` and a fixed +tap count of ``256``. An application is free to supply its own filter +coefficients for the first stage decimator (using the fixed decimation factor +and tap count), however this library also provides a reference filter for the +first stage decimator that is recommended for most applications. + +The first stage decimating filter is an FIR filter with 16-bit coefficients, and +where each input sample corresponds to a ``+1`` or a ``-1`` (typical for PDM +signals). The output of the first stage decimator is a block of 32-bit PCM +samples with a sample time ``32`` times longer than the PDM sample time. + +See :ref:`decimator_stages` for further details. + +Step 3: Second Stage Decimation +******************************* + +The second stage decimator is a decimating FIR filter with a configurable +decimation factor and tap count. Like the first stage decimator, this library +provides a reference filter suitable for the second stage decimator. The +supplied filter has a tap count of ``65`` and a decimation factor of ``6``. + +The output of the first stage decimator is a block of ``N*K`` PCM values, +where ``N`` is the number of microphones and ``K`` is the second stage +decimation factor. This is just enough samples to produce one output sample from +the second stage decimator. + +The resulting sample is vector-valued (one element per channel) and has a sample +time corresponding to ``32*K`` PDM clock periods. Using the reference filters +and a 3.072 MHz PDM clock, the output sample rate is 16 kHz. + +See :ref:`decimator_stages` for further details. + +Step 4: Post-Processing +*********************** + +After second stage decimation, the resulting sample goes to post-processing +where two (optional) post-processing steps are available. + +The first is a simple IIR filter, called DC Offset Elimination, which seeks to +ensure each output channel tends to approach zero mean. DC Offset Elimination +can be disabled if not desired. See :ref:`sample_filters` for further details. + +The second post-processing step is framing, where instead of signaling each +sample of audio to subsequent processing stages one at a time, samples can be +aggregated and transferred to subsequent processing stages as non-overlapping +blocks. The size of each frame is configurable (down to ``1`` sample per frame, +where framing is functionally disabled). + +Finally, the sample or frame is transmitted over a channel from the mic array +module to the next stage of the processing pipeline. + +Extending/Modifying Mic Array Behavior +************************************** + +At the core of ``lib_mic_array`` are several C++ class templates which are +loosely coupled and intended to be easily overridden for modified behavior. The +mic array unit itself is an object made by the composition of several smaller +components which perform well-defined roles. + +For example, modifying the mic array unit to use some mechanism other than a +channel to move the audio frames out of the mic array is a matter of defining a +small new class encapsulating just the modified transfer behavior, and then +instantiating the mic array class template with the new class as the appropriate +template parameter. + +With that in mind, while most applications will have no need to modify the mic +array behavior, it is nevertheless designed to be easy to do so. \ No newline at end of file diff --git a/doc/programming_guide/src/reference/api_index.rst b/doc/programming_guide/src/reference/api_index.rst new file mode 100644 index 00000000..11936d19 --- /dev/null +++ b/doc/programming_guide/src/reference/api_index.rst @@ -0,0 +1,9 @@ +############# +API Reference +############# + +.. toctree:: + :maxdepth: 2 + + cpp/cpp_api + c/c_api diff --git a/doc/programming_guide/src/reference/c/c_api.rst b/doc/programming_guide/src/reference/c/c_api.rst new file mode 100644 index 00000000..5cdf4c05 --- /dev/null +++ b/doc/programming_guide/src/reference/c/c_api.rst @@ -0,0 +1,14 @@ +############### +C API Reference +############### + +.. toctree:: + :maxdepth: 1 + + filters_default + pdm_resources + setup + frame_transfer + dc_elimination + util + mic_array_vanilla \ No newline at end of file diff --git a/doc/programming_guide/src/reference/c/dc_elimination.rst b/doc/programming_guide/src/reference/c/dc_elimination.rst new file mode 100644 index 00000000..e7602906 --- /dev/null +++ b/doc/programming_guide/src/reference/c/dc_elimination.rst @@ -0,0 +1,9 @@ +dc_elimination.h +================ + +.. doxygenstruct:: dcoe_chan_state_t + :members: + +.. doxygenfunction:: dcoe_state_init + +.. doxygenfunction:: dcoe_filter diff --git a/doc/programming_guide/src/reference/c/filters_default.rst b/doc/programming_guide/src/reference/c/filters_default.rst new file mode 100644 index 00000000..c8d05da9 --- /dev/null +++ b/doc/programming_guide/src/reference/c/filters_default.rst @@ -0,0 +1,82 @@ +filters_default.h +================= + +The filters described below are the first and second stage filters provided by +this library which are used with the +:cpp:class:`TwoStageDecimator ` class template by +default. + +Stage 1 - PDM-to-PCM Decimating FIR Filter +------------------------------------------ + +.. code-block:: + + Decimation Factor: 32 + Tap Count: 256 + +The first stage decimation FIR filter converts 1-bit PDM samples into 32-bit +PCM samples and simultaneously decimates by a factor of 32. + +A typical input PDM sample rate will be 3.072M samples/sec, thus the +corresponding output sample rate will be 96k samples/sec. + +The first stage filter uses 16-bit coefficients for its taps. Because +this is a highly optimized filter targeting the VPU hardware, the first +stage filter is presently restricted to using exactly 256 filter taps. + +For more information about the example first stage filter supplied with the +library, including frequency response and steps for using a custom first stage +filter, see :ref:`decimator_stages`. + + +.. doxygendefine:: STAGE1_DEC_FACTOR + +.. doxygendefine:: STAGE1_TAP_COUNT + +.. doxygendefine:: STAGE1_WORDS + +.. doxygenvariable:: stage1_coef + + + +Stage 2 - PCM Decimating FIR Filter +----------------------------------- + +.. code-block:: + + Decimation Factor: (configurable) + Tap Count: (configurable) + +The second stage decimation FIR filter filters and downsamples the +32-bit PCM output stream from the first stage filter into another +32-bit PCM stream with sample rate reduced by the stage 2 decimation +factor. + +A typical first stage output sample rate will be 96k samples/sec, a +decimation factor of 6 (i.e. using the default stage 2 filter) will +mean a second stage output sample rate of 16k samples/sec. + +The second stage filter uses 32-bit coefficients for its taps. A +complete description of the FIR implementation is outside the scope +of this documentation, but it can be found in the ```xs3_filter_fir_s32_t``` +documentation of ``lib_xcore_math``. + +In brief, the second stage filter coefficients are quantized to a Q1.30 +fixed-point format with input samples treated as integers. The tap outputs +are added into a 40-bit accumulator, and an output sample is produced by +applying a rounding arithmetic right-shift to the accumulator and then +clipping the result to the interval ``[INT32_MAX, INT32_MIN)``. + +For more information about the example second stage filter supplies with the +library, including frequency response and steps for using a custom filter, +see :ref:`decimator_stages`. + + +.. doxygendefine:: STAGE2_DEC_FACTOR + +.. doxygendefine:: STAGE2_TAP_COUNT + +.. doxygenvariable:: stage2_coef + +.. doxygenvariable:: stage2_shr + diff --git a/doc/programming_guide/src/reference/c/frame_transfer.rst b/doc/programming_guide/src/reference/c/frame_transfer.rst new file mode 100644 index 00000000..f3e6f971 --- /dev/null +++ b/doc/programming_guide/src/reference/c/frame_transfer.rst @@ -0,0 +1,8 @@ +frame_transfer.h +================ + +.. doxygenfunction:: ma_frame_tx + +.. doxygenfunction:: ma_frame_rx + +.. doxygenfunction:: ma_frame_rx_transpose diff --git a/doc/programming_guide/src/reference/c/mic_array_vanilla.rst b/doc/programming_guide/src/reference/c/mic_array_vanilla.rst new file mode 100644 index 00000000..388e0811 --- /dev/null +++ b/doc/programming_guide/src/reference/c/mic_array_vanilla.rst @@ -0,0 +1,6 @@ +mic_array_vanilla.h +=================== + +.. doxygenfunction:: ma_vanilla_init + +.. doxygenfunction:: ma_vanilla_task diff --git a/doc/programming_guide/src/reference/c/pdm_resources.rst b/doc/programming_guide/src/reference/c/pdm_resources.rst new file mode 100644 index 00000000..1665f085 --- /dev/null +++ b/doc/programming_guide/src/reference/c/pdm_resources.rst @@ -0,0 +1,9 @@ +pdm_resources.h +=============== + +.. doxygenstruct:: pdm_rx_resources_t + :members: + +.. doxygendefine:: PDM_RX_RESOURCES_SDR + +.. doxygendefine:: PDM_RX_RESOURCES_DDR \ No newline at end of file diff --git a/doc/programming_guide/src/reference/c/setup.rst b/doc/programming_guide/src/reference/c/setup.rst new file mode 100644 index 00000000..839e11f8 --- /dev/null +++ b/doc/programming_guide/src/reference/c/setup.rst @@ -0,0 +1,8 @@ +setup.h +======= + +.. doxygenfunction:: mic_array_resources_configure + +.. doxygenfunction:: mic_array_pdm_clock_start + +.. doxygenfunction:: mic_array_mclk_divider \ No newline at end of file diff --git a/doc/programming_guide/src/reference/c/util.rst b/doc/programming_guide/src/reference/c/util.rst new file mode 100644 index 00000000..318ffcfc --- /dev/null +++ b/doc/programming_guide/src/reference/c/util.rst @@ -0,0 +1,8 @@ +util.h +====== + +.. doxygenfunction:: deinterleave2 + +.. doxygenfunction:: deinterleave4 + +.. doxygenfunction:: deinterleave8 \ No newline at end of file diff --git a/doc/programming_guide/src/reference/cpp/cpp_api.rst b/doc/programming_guide/src/reference/cpp/cpp_api.rst new file mode 100644 index 00000000..a9f0f9c8 --- /dev/null +++ b/doc/programming_guide/src/reference/cpp/cpp_api.rst @@ -0,0 +1,148 @@ +################# +C++ API Reference +################# + + + +MicArray +======== + +.. doxygenclass:: mic_array::MicArray + :members: + +.. raw:: latex + + \newpage + + + + +BasicMicArray +============= + +.. doxygenclass:: mic_array::prefab::BasicMicArray + :members: + +.. raw:: latex + + \newpage + + + + + +PdmRxService +============ + + +.. doxygenclass:: mic_array::PdmRxService + :members: + +StandardPdmRxService +-------------------- + +.. doxygenstruct:: pdm_rx_isr_context_t + :members: + +.. doxygenvariable:: pdm_rx_isr_context + +.. doxygenfunction:: enable_pdm_rx_isr + +.. doxygenclass:: mic_array::StandardPdmRxService + :members: + +.. raw:: latex + + \newpage + + + + + +TwoStageDecimator +================= + +.. doxygenclass:: mic_array::TwoStageDecimator + :members: + +.. raw:: latex + + \newpage + + + + + + +SampleFilter +============ + + +NopSampleFilter +--------------- + +.. doxygenclass:: mic_array::NopSampleFilter + :members: + +DcoeSampleFilter +---------------- + +.. doxygenclass:: mic_array::DcoeSampleFilter + :members: + +.. raw:: latex + + \newpage + + + + + + + +OutputHandler +================= + +An OutputHandler is a class which meets the requirements to be used as the +``TOutputHandler`` template parameter of the +:cpp:class:`MicArray ` class template. The basic +requirement is that it have a method: + +.. code-block::c++ + + void OutputSample(int32_t sample[MIC_COUNT]); + +This method is how the mic array communicates its output with the rest of the +application's audio processing pipeline. `MicArray` calls this method once for +each mic array output sample. + +See :cpp:member:`MicArray::OutputHandler ` +for more details. + +FrameOutputHandler +------------------ + +.. doxygenclass:: mic_array::FrameOutputHandler + :members: + + +ChannelFrameTransmitter +*********************** + +.. doxygenclass:: mic_array::ChannelFrameTransmitter + :members: + +.. raw:: latex + + \newpage + + + + + + +Misc +==== + +.. doxygenfunction:: mic_array::deinterleave_pdm_samples + diff --git a/doc/programming_guide/src/resource_usage.rst b/doc/programming_guide/src/resource_usage.rst new file mode 100644 index 00000000..101af795 --- /dev/null +++ b/doc/programming_guide/src/resource_usage.rst @@ -0,0 +1,217 @@ +.. _resource_usage: + +Mic Array Resource Usage +######################## + +The mic array unit requires several kinds of hardware resources, including +ports, clock blocks, chanends, hardware threads, compute time (MIPS) and memory. +Compared to previous versions of this library, the biggest advantage to the +current version with respect to hardware resources is a greatly reduced compute +requirement. This was made possible by the introduction of the VPU in the XMOS +XS3 architecture. The VPU can do certain operations in a single instruction +which would take many, many instructions on previous architectures. + +This page attempts to capture the requirements for each hardware type with +relevant configurations. + +.. warning:: + The usage information below applies when the Vanilla API or prefab APIs are + used. Resource usage in an application which uses custom mic array + sub-components will depend crucially on the specifics of the customization. + +Discrete Resources +================== + ++-------------------+--------------------+ +| Resource | Count | ++===================+====================+ +| port | 3 | ++-------------------+--------------------+ +| clock block | 1 (SDR) | +| | | +| | 2 (DDR) | ++-------------------+--------------------+ +| chanend | 4 | +| | | ++-------------------+--------------------+ +| thread | 1 (Vanilla) | +| | | +| | 1 or 2 (prefab) | ++-------------------+--------------------+ + +Ports +----- + +In all configurations, the mic array unit requires 3 of the xcore.ai device's +hardware ports. Two of these ports (for the master audio clock and PDM clock) +must be 1-bit ports. The third (PDM capture port) can be 1-, 4- or 8-bit, +depending on the microphone count and SDR/DDR configuration. + +Clock Blocks +------------ + +In applications which use an SDR microphone configuration, the mic array unit +requires 1 of the xcore.ai device's 5 clock blocks. This clock block is used +both to generate the PDM clock from the master audio clock and as the PDM +capture clock. + +In applications which use a DDR microphone configuration, the mic array unit +requires 2 of the xcore.ai device's 5 clock blocks. One clock is used to +generate the PDM clock from the master audio clock, and the other is used as the +PDM capture clock (which must operate at different rates in a DDR +configuration). + +Chanends +-------- + +Chanends are a hardware resource which allow threads (possibly running on +different tiles) to communicate over channels. The mic array unit requires 4 +chanends. Two are used for communication between the PDM rx service and the +decimation thread. Two more are needed for transfering completed frames from the +mic array unit to other application components. + +Threads +------- + +The prefab API can run the PDM rx service either as a stand-alone thread or as +an interrupt in another thread. The Vanilla API only supports running it as an +interrupt. The Vanilla API requires only on hardware thread. The prefab API +requires 1 thread if PDM rx is used in interrupt mode, and 2 if PDM rx is a +stand-alone thread.. + +Running PDM rx as a stand-alone thread modestly reduces the mic array unit's +MIPS consumption by eliminating the context switch overhead of an interrupt. The +cost of that is one hardware thread. + +.. note:: + + When configured as an interrupt, PDM rx ISR is typically configured on the + decimation thread, but this is not a strict requirement. The PDM rx interrupt + can be configured for any thread on the same tile as the decimation thread. + They must be on the same tile because shared memory is used between the two + contexts. + + +Compute +======= + +The compute requirement of the mic array unit depends strongly on the actual +configuration being used. The compute requirement is expressed in millions of +instructions per second (MIPS) and is approximately linearly related to many +of the configuration parameters. + +Each tile of an xcore.ai device has 8 hardware threads and a 5 stage pipline. +The exact calculation of how many MIPS are available to a thread is complicated, +and is, in general, affected by both the number of threads being used, as well +as the work being done by each thread. + +As a rule of thumb, however, the core scheduler will offer each thread a minimum +of ``CORE_CLOCK_MHZ/8`` millions of instruction issue slots per second (~MIPS), +and no more than ``CORE_CLOCK_MHZ/5`` millions of issue slots per second, where +``CORE_CLOCK_MHZ`` is the core CPU clock rate. With a core clock rate of 600 +MHz, that means that each core should expect at least 75 MIPS. + +The MIPS values in the table below are estimates obtained using the demo +applications in ``demo/measure_mips``. + + ++------------+------+------+-------+-------+-------+-------+-------+ +| PDM Freq | S2DF | S2TC | PdmRx | 1 mic | 2 mic | 4 mic | 8 mic | +| | | | | MIPS | MIPS | MIPS | MIPS | ++============+======+======+=======+=======+=======+=======+=======+ +| 3.072 MHz | 6 | 65 | ISR | 10.65 | 22.00 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ +| 3.072 MHz | 6 | 65 |Thread | 9.33 | 19.37 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ +| 6.144 MHz | 6 | 65 | ISR | 21.26 | 43.89 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ +| 6.144 MHz | 6 | 65 |Thread | 18.66 | 38.73 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ +| 3.072 MHz | 3 | 65 | ISR | 12.90 | 26.44 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ +| 3.072 MHz | 3 | 65 |Thread | 11.62 | 23.85 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ +| 3.072 MHz | 6 | 130 | ISR | 11.17 | 23.04 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ +| 3.072 MHz | 6 | 130 |Thread | 9.86 | 20.42 | TBD | TBD | ++------------+------+------+-------+-------+-------+-------+-------+ + +PDM Freq + Frequency of the PDM clock. + +S2DF + Stage 2 decimation factor. Output sample rate is ``(PDM Freq / (32 * S2DF))``. + +S2TC + Stage 2 tap count. + +PdmRx + Whether PDM capture is done in a stand-alone thread or in an ISR. + +Measurements indicate that enabling or disabling the DC offset removal filter +has little effect on the MIPS usage. The selected frame size has only a slight +negative correlation with MIPS usage. + + + +Memory +====== + +The memory cost of the mic array unit has three parts: code, stack and data. +Code is the memory needed to store compiled instructions in RAM. Stack is the +memory required to store intermediate results during function calls, and data is +the memory used to store persistant objects, variables and constants. + +The stack memory requirement is minimal. The code memory requirement depends on +the particular configuration, but ranges from about ``1600`` bytes in a 1 mic +configuration to about ``2000`` bytes in an 8 mic configuration. + +Not included in the table is the space allocated for the first and second stage +filter coefficients. The first stage filter coefficients take a constant ``523`` +bytes. The second stage filter coefficients use ``4*S2TC`` bytes, where ``S2TC`` +is the stage 2 decimator tap count. The value shown in the 'data' column of the +table is the ``sizeof()`` the +:cpp:class:`BasicMicArray ` that is +instantiated. The table below indicates the data size for various +configurations. + ++------+------+------+------+-------+--------------+ +| Mics | S2DF | S2TC | SPF | DCOE | Data Memory | ++======+======+======+======+=======+==============+ +| 1 | 6 | 65 | 16 | On | 504 B | ++------+------+------+------+-------+--------------+ +| 2 | 6 | 65 | 16 | On | 968 B | ++------+------+------+------+-------+--------------+ +| 4 | 6 | 65 | 16 | On | 1888 B | ++------+------+------+------+-------+--------------+ +| 8 | 6 | 65 | 16 | On | 3728 B | ++------+------+------+------+-------+--------------+ +| 1 | 6 | 65 | 16 | On | 768 B | ++------+------+------+------+-------+--------------+ +| 2 | 6 | 130 | 16 | On | 1488 B | ++------+------+------+------+-------+--------------+ +| 1 | 6 | 130 | 16 | On | 576 B | ++------+------+------+------+-------+--------------+ +| 2 | 12 | 65 | 16 | On | 1112 B | ++------+------+------+------+-------+--------------+ +| 1 | 12 | 65 | 160 | On | 1080 B | ++------+------+------+------+-------+--------------+ +| 2 | 6 | 65 | 160 | On | 2120 B | ++------+------+------+------+-------+--------------+ +| 1 | 6 | 65 | 16 | Off | 496 B | ++------+------+------+------+-------+--------------+ +| 2 | 6 | 65 | 16 | Off | 948 B | ++------+------+------+------+-------+--------------+ + + +S2DF + Stage 2 decimator's decimation factor. + +S2TC + Stage 2 decimator's tap count. + +SPF + Samples per frame in frames delivered by the mic array unit. + +DCOE + DC Offset Elimination \ No newline at end of file diff --git a/doc/programming_guide/src/sample_filters.rst b/doc/programming_guide/src/sample_filters.rst new file mode 100644 index 00000000..564c7bd2 --- /dev/null +++ b/doc/programming_guide/src/sample_filters.rst @@ -0,0 +1,145 @@ +.. _sample_filters: + +Sample Filters +============== + +Following the two-stage decimation procedure is an optional post-processing +stage called the sample filter. This stage operates on each sample emitted by +the second stage decimator, one at a time, before the samples are handed off for +framing or transfer to the rest of the application's audio pipeline. + +.. note:: + + This is represented by the ``SampleFilter`` sub-component of the + :cpp:class:`MicArray ` class template. + +An application may implement its own sample filter in the form of a C++ class +which implements the ``Filter()`` function as required by ``MicArray``. See the +implementation of :cpp:class:`DcoeSampleFilter ` +for a simple example. + +DC Offset Elimination +--------------------- + +The current version of this library provides a simple IIR filter called DC +Offset Elimination (DCOE) that can be used as the sample filter. This is a +high-pass filter meant to ensure that each audio channel will tend towards a +mean sample value of zero. + +Enabling/Disabling DCOE +*********************** + +Whether the DCOE filter is enabled by default and how to enable or disable it +depends on which approach your project uses to include the mic array component +in the application. + +Vanilla Model +''''''''''''' + +If your project uses the vanilla model (see :ref:`vanilla_api`) to include the +mic array unit in your application, then DCOE is **enabled** by default. To +disable DCOE your build script must add a compiler option to your application +target that sets the ``MIC_ARRAY_CONFIG_USE_DC_ELIMINATION`` preprocessor macro +to the value ``0``. + +For example, in a typical application's ``CMakeLists.txt``, that may look like +the following. + +.. code-block:: cmake + + # Gather sources and create application target + # ... + # Add vanilla source to application build + mic_array_vanilla_add(my_app ${MCLK_FREQ} ${PDM_FREQ} + ${MIC_COUNT} ${FRAME_SIZE} ) + # ... + # Disable DCOE + target_compile_definitions(my_app + PRIVATE MIC_ARRAY_CONFIG_USE_DC_ELIMINATION=0 ) + + +Prefab Model +'''''''''''' + +If your project instantiates the +:cpp:class:`BasicMicArray ` class template to +include the mic array unit, DC offset elimination is enabled or disabled with +the ``USE_DCOE`` boolean template parameter (there is no default). + +.. code-block:: c++ + + template + class BasicMicArray : public ... + + +The sample filter chosen is based on the ``USE_DCOE`` template parameter when +the class template gets instantiated. If ``true``, +:cpp:class:`DcoeSampleFilter ` will be selected as +the ``MicArray`` ``SampleFilter`` sub-component. Otherwise +:cpp:class:`NopSampleFilter ` will be used. + +.. note:: + + ``NopSampleFilter`` is a no-op filter -- it does not modify the samples given + to it and ultimately will be completely optimized out at compile time. + +For example, in your application source: + +.. code-block:: c++ + + #include "mic_array/mic_array.h" + ... + // Controls whether DCOE is enabled + static constexpr bool enable_dcoe = true; + auto mics = mic_array::prefab::BasicMicArray(); + ... + + +General Model +''''''''''''' + +If your project does not use either the vanilla or prefab models to include the +mic array unit in your application, then precisely how the DCOE filter is +included may depend on the specifics of your application. In general, however, +the DCOE filter will be enabled by using +:cpp:class:`DcoeSampleFilter ` as the +``TSampleFilter`` template parameter for the +:cpp:class:`MicArray ` class template. + +For example, sub-classing ``mic_array::MicArray`` as follows will enable DCOE +for any ``MicArray`` implementation deriving from that sub-class. + +.. code-block:: c++ + + #include "mic_array/cpp/MicArray.hpp" + using namespace mic_array; + ... + template + class DcoeEnabledMicArray : public MicArray + { + ... + }; + + +DCOE Filter Equation +******************** + +As mentioned above, the DCOE filter is a simple IIR filter given by the +following equation, where ``x[t]`` and ``x[t-1]`` are the current and previous +input sample values respectively, and ``y[t]`` and ``y[t-1]`` are the current +and previous output sample values respectively. + +:: + + R = 255.0 / 256.0 + y[t] = R * y[t-1] + x[t] - x[t-1] + + +DCOE Filter Frequency Response +****************************** + +The plot below indicates the frequency response of DCOE filter. + +.. image:: dcoe_freq_response.png diff --git a/doc/programming_guide/src/software_structure.rst b/doc/programming_guide/src/software_structure.rst new file mode 100644 index 00000000..934bae93 --- /dev/null +++ b/doc/programming_guide/src/software_structure.rst @@ -0,0 +1,309 @@ +.. _software_structure: + +Software Structure +================== + +The core of ``lib_mic_array`` are a set of C++ class templates representing the +mic array unit and its sub-components. + +The template parameters of these class templates are (mainly) used for two +different purposes. Non-type template parameters are used to specify certain +quantitative configuration values, such as the number of microphone channels or +the second stage decimator tap count. Type template parameters, on the other +hand, are used for configuring the behavior of sub-components. + +High-Level View +--------------- + +At the heart of the mic array API is the +:cpp:class:`MicArray ` class template. + +.. note:: + + All classes and class templates mentioned are in the ``mic_array`` C++ + namespace unless otherwise specified. Additionally, this documentation may + refer to class templates (e.g. ``MicArray``) with unbound template + parameters as "classes" when doing so is unlikely to lead to confusion. + +The :cpp:class:`MicArray ` class template looks like the +following: + +.. code-block:: c++ + + template + class MicArray; + + +Here the non-type template parameter ``MIC_COUNT`` indicates the number of +microphone channels to be captured and processed by the mic array unit. Most of +the class templates have this as a parameter. + +A ``MicArray`` object comprises 4 sub-components: + + ++-----------------------------------------------------------------+-------------------------+--------------------------------+ +| Member Field | Component Class | Responsibility | ++=================================================================+=========================+================================+ +| :cpp:member:`PdmRx ` | ``TPdmRx`` | Capturing PDM data from a port.| ++-----------------------------------------------------------------+-------------------------+--------------------------------+ +| :cpp:member:`Decimator ` | ``TDecimator`` | 2-stage decimation on blocks of| +| | | PDM data. | ++-----------------------------------------------------------------+-------------------------+--------------------------------+ +| :cpp:member:`SampleFilter ` | ``TSampleFilter`` | Post-processing of decimated | +| | | samples. | ++-----------------------------------------------------------------+-------------------------+--------------------------------+ +| :cpp:member:`OutputHandler `| ``TOutputHandler`` | Transferring audio data to | +| | | subsequent pipeline stages. | ++-----------------------------------------------------------------+-------------------------+--------------------------------+ + + +Each of the ``MicArray`` sub-components has a type that is specified as a +template parameter when the class template is instantiated. ``MicArray`` +requires the class of each of its sub-components to implement a certain minimal +interface. The ``MicArray`` object interacts with its sub-components using this +interface. + +.. note:: + + Abstract classes are **not** used to enforce this interface contract. Instead, + the contract is enforced (at compile time) solely in how the ``MicArray`` + object makes use of the sub-component. + +The following diagram conceptually captures the flow of information through the +``MicArray`` sub-components. + +.. figure:: diagrams/high_level_process.drawio.png + :align: center + :scale: 100 % + :alt: Mic Array High Level Process + +.. note:: + + ``MicArray`` does not enforce the use of an XCore port for collecting PDM + samples or an XCore channel for transferring processed data. This is just the + typical usage. + +Mic Array / Decimator Thread +**************************** + +Aside from aggregating its sub-components into a single logical entity, the +``MicArray`` class template also holds the high-level logic for capturing, +processing and coordinating movement of the audio stream data. + +The following code snippet is the implementation for the main mic array thread +(or "decimation thread"; not to be confused with (optional) PDM capture thread). + +.. code-block:: c++ + + void mic_array::MicArray::ThreadEntry() + { + int32_t sample_out[MIC_COUNT] = {0}; + + while(1){ + uint32_t* pdm_samples = PdmRx.GetPdmBlock(); + Decimator.ProcessBlock(sample_out, pdm_samples); + SampleFilter.Filter(sample_out); + OutputHandler.OutputSample(sample_out); + } + } + + +The thread loops forever, and on each iteration + +* Requests a block of PDM sample data from the PDM rx service. This is a + blocking call which only returns once a complete block becomes + available. +* Passes the block of PDM sample data to the decimator to produce a single + output sample. +* Applies a post-processing filter to the sample data. +* Passes the processed sample to the output handler to be transferred to the + next stage of the processing pipeline. This may also be a blocking call, only + returning once the data has been + transferred. + +Note that the ``MicArray`` object doesn't care how these steps are actually +implemented. For example, one output handler implementation may send samples +one at a time over a channel. Another output handler implementation may collect +samples into frames, and use a FreeRTOS queue to transfer the data to another +thread. + + +.. _crtp: + +Curiously Recurring Template Pattern +************************************ + +The C++ API of this library makes heavy use of the `Curiously Recurring Template +Pattern `_ +(CRTP). + +Instead of providing flexibility through abstract classes or polymorphism, CRTP +achieves flexibility through the use of class templates with type template +parameters. As with derived classes and virtual methods, the CRTP template +parameter must follow a contract with the class template where it implements +one or more methods with specific names and signatures that the class template +directly calls. + +There are a couple notable advantages of using CRTP over polymorphic behavior. +With CRTP flexibility does not generally come with the same run-time costs (in +terms of both compute and memory) as polymorphic solutions. This is because the +CRTP class template always knows the concrete type of any objects it uses at +compile time. This avoids the need for run time type information or virtual +function tables. This allows compile time optimizations can be made which may +not be otherwise available. This in-turn allows many function calls to be +inlined, or in some cases, entirely eliminated. + +Additionally, while not strictly an example of CRTP, integer template parameters +are also heavily used in class templates. The two main advantages of this are +that it allows objects to encapsulate their own (statically allocated) memory, +and that it allows the compiler to make compile time loop optimizations that it +may not otherwise be able to make. + +The downside to CRTP is that it tends to lead to highly verbose class type +names, where templated classes end up with type parameter assignments are +themselves templated classes with their own template parameters. + +Sub-Component Initialization +**************************** + +Each of ``MicArray``'s sub-components may have implementation-specific +configuration or initialization requirements. Each sub-component is a ``public`` +member of ``MicArray`` (see table above). An application can access a +sub-component directly to perform any type-specific initialization or other +manipulation. + +For example, the +:cpp:class:`ChannelFrameTransmitter ` output +handler class needs to know the ``chanend`` to be used for sending samples. This +can be initialized on a ``MicArray`` object ``mics`` with +``mics.OutputHandler.SetChannel(c_sample_out)``. + + +Sub-Components +-------------- + +PdmRx +***** + +:cpp:member:`PdmRx `, or the PDM rx service is the +``MicArray`` sub-component responsible for capturing PDM sample data, assembling +it into blocks, and passing it along so that it can be decimated. + +The ``MicArray`` class requires only that ``PdmRx`` implement ``GetPdmBlock()``, +a blocking call that returns a pointer to a block of PDM data which is ready for +further processing. + +Generally speaking, ``PdmRx`` will derive from the +:cpp:class:`PdmRxService ` +class template. ``PdmRxService`` encapsulates the logic of using an xCore +``port`` for capturing PDM samples one word (32 bits) at a time, and managing +two buffers where blocks of samples are collected. It also simplifies the logic +of running PDM rx as either an interrupt or as a stand-alone thread. + +``PdmRxService`` has 2 template parameters. The first is the ``BLOCK_SIZE``, +which specifies the size of a PDM sample block (in words). The second, +``SubType``, is the type of the sub-class being derived from ``PdmRxService``. +This is the CRTP (Curiously Recurring Template Pattern), which allows a base +class to use polymorphic-like behaviors while ensuring that all types are known +at compile-time, avoiding the drawbacks of using virtual functions. + +There is currently one class template which derives from ``PdmRxService``, +called :cpp:class:`StandardPdmRxService `. +``StandardPdmRxService`` uses a streaming channel to transfer PDM blocks to the +decimator. It also provides methods for installing an optimized ISR for PDM +capture. + +Decimator +********* + +The :cpp:member:`Decimator ` sub-component +encapsulates the logic of converting blocks of PDM samples into PCM samples. The +:cpp:class:`TwoStageDecimator ` class is a +decimator implementation that uses a pair of decimating FIR filters to +accomplish this. + +The first stage has a fixed tap count of ``256`` and a fixed decimation factor +of ``32``. The second stage has a configurable tap count and decimation factor. + +For more details, see :ref:`decimator_stages`. + +SampleFilter +************ + +The :cpp:member:`SampleFilter ` sub-component +is used for post-processing samples emitted by the decimator. Two +implementations for the sample filter sub-component are provided by this +library. + +The :cpp:class:`NopSampleFilter ` class can be used +to effectively disable per-sample filtering on the output of the decimator. It +does nothing to the samples presented to it, and so calls to it can be optimized +out during compilation. + +The :cpp:class:`DcoeSampleFilter ` class is used +for applying the DC offset elimination filter to the decimator's output. The DC +offset elimination filter is meant to ensure the sample mean for each channel +tends toward zero. + +For more details, see :ref:`sample_filters`. + +OutputHandler +************* + +The :cpp:member:`OutputHandler ` +sub-component is responsible for transferring processed sample data to +subsequent processing stages. + +There are two main considerations for output handlers. The first is whether +audio data should be transferred *sample-by-sample* or as *frames* containing +many samples. The second is the method of actually transferring the audio data. + +The class +:cpp:class:`ChannelSampleTransmitter ` +sends samples one at a time to subsequent processing stages using an xCore +channel. + +The :cpp:class:`FrameOutputHandler ` class +collects samples into frames, and uses a frame transmitter to send the frames +once they're ready. + +Prefabs +------- + +One of the drawbacks to broad use of class templates is that concrete class +names can unfortunately become excessively verbose and confusing. For example, +the following is the fully qualified name of a (particular) concrete +``MicArray`` implementation: + +.. code-block:: c++ + + mic_array::MicArray<2, + mic_array::TwoStageDecimator<2,6,65>, + mic_array::StandardPdmRxService<2,2,6>, + mic_array::DcoeSampleFilter<2>, + mic_array::FrameOutputHandler<2,256, + mic_array::ChannelFrameTransmitter>> + + +This library also provides a C++ namespace ``mic_array::prefab`` which is +intended to simplify construction of ``MicArray`` objects where common +configurations are needed. + +The :cpp:class:`BasicMicArray ` class template +uses the most typical component implementations, where PDM rx can be run as an +interrupt or as a stand-alone thread, and where audio frames are transmitted to +subsequent processing stages using a channel. + +To demonstrate how ``BasicMicArray`` simplifies this process, observe that the +following ``MicArray`` type is behaviorally identical to the above: + +.. code-block:: c++ + + mic_array::prefab::BasicMicArray<2,256,true> + diff --git a/doc/programming_guide/src/stage1_freq_response.png b/doc/programming_guide/src/stage1_freq_response.png new file mode 100644 index 00000000..06dc224b Binary files /dev/null and b/doc/programming_guide/src/stage1_freq_response.png differ diff --git a/doc/programming_guide/src/stage2_freq_response.png b/doc/programming_guide/src/stage2_freq_response.png new file mode 100644 index 00000000..01ab86ab Binary files /dev/null and b/doc/programming_guide/src/stage2_freq_response.png differ diff --git a/doc/programming_guide/src/vanilla_api.rst b/doc/programming_guide/src/vanilla_api.rst new file mode 100644 index 00000000..b5b85c3f --- /dev/null +++ b/doc/programming_guide/src/vanilla_api.rst @@ -0,0 +1,206 @@ +.. _vanilla_api: + +Vanilla API +########### + +The Vanilla API is a small optional API which greatly simplifies the process of +including a mic array unit in an xcore.ai application. Most applications that +make use of a PDM mic array will not have complicated needs from the mic array +software component beyond delivery of frames of audio data from a configurable +set of microphones at a configurable rate. This API targets that majority of +applications. + +The prefab API requires the application developer to have at least some +minimal understanding of the objects and classes associated with the mic array +unit, and requires the developer to write some application-specific code to +configure and start the mic array. The Vanilla API (which builds on top of the +prefab model) by contrast, requires as little as two standard function calls, +and instead moves the majority of the application logic into the application's +build project. + +.. note:: + + **Why "Vanilla"?** "Vanilla" was originally meant as a generic placeholder + name, but no better name was ever suggested. + +How It Works +============ + +The Vanilla API comprises two code files, ``etc/vanilla/mic_array_vanilla.cpp`` +and ``etc/vanilla/mic_array_vanilla.h`` which are not compiled as part of this +library. Instead, if used, these are added to the application target's build. To +control configuration, the source file relies on a set of pre-processor macros +(added via compile flags) which determine how the mic array unit will be +instantiated. + +The API is included in an application by using a CMake macro +(``mic_array_vanilla_add()``) provided in this library. The macro updates the +application's sources, includes and compile definitions to include the API. + +In the application code, two function calls are needed. First, +:c:func:`ma_vanilla_init()` is called to initialize the various mic array +sub-components, preparing for capture of PDM data. Then, to start capture the +decimation thread is started with :c:func:`ma_vanilla_task()` as entrypoint. +:c:func:`ma_vanilla_task()` takes an XCore ``chanend`` as a parameter, which +tells it where completed audio frames should be routed. + +.. note:: + + The Vanilla API runs the PDM rx service as an interrupt in the decimation + thread. To run it as a separate thread (for reduced total MIPS consumption) + one of the lower-level APIs must be used. + +As with the prefab API, audio frames are extracted from the mic array unit over +a (non-streaming) channel using the :c:func:`ma_frame_rx()` or +:c:func:`ma_frame_rx_transpose()` functions. + +.. note:: + + The Vanilla API uses the default filters provided with this library, + and does not currently provide a way to override this. To use custom filters, + you must either use a lower-level API or modify the vanilla API. + +Configuration +============= + +Configuration with the Vanilla API is achieved through compile definitions. The +required definitions are provided through the ``mic_array_vanilla_add()`` macro. +There are several additional optional definitions. + +mic_array_vanilla_add() +----------------------- + +``mic_array_vanilla_add()`` is the CMake macro used to add the Vanilla API to an +application. + +.. code-block:: cmake + + macro( mic_array_vanilla_add + TARGET_NAME + MCLK_FREQ + PDM_FREQ + MIC_COUNT + SAMPLES_PER_FRAME ) + +``TARGET_NAME`` + The name of the application's CMake target. It is the target the Vanilla API + is added to. + +``MCLK_FREQ`` + The known frequency, in Hz, of the application's master audio clock. A typical + frequency is 24576000 Hz. Note that this parameter is not *configuring* the + master audio clock. (Equivalent compile definition: + ``MIC_ARRAY_CONFIG_MCLK_FREQ``) + +``PDM_FREQ`` + The desired frequency, in Hz, of the PDM clock. This should be an integer + factor of ``MCLK_FREQ`` between ``1`` and ``510``. (Equivalent compile + definition: ``MIC_ARRAY_CONFIG_PDM_FREQ``) + +``MIC_COUNT`` + The number of PDM microphone channels to be captured. This API supports values + of ``1`` (SDR), ``2`` (DDR), ``4`` (SDR) and ``8`` (SDR/DDR). This value must + match the configuration (SDR/DDR) and port width of the PDM capture port. That + is, in an SDR port configuration, ``MIC_COUNT`` must equal the capture port + width, and in DDR port configuration, ``MIC_COUNT`` must be twice the port + width. (Equivalent compile definition: ``MIC_ARRAY_CONFIG_MIC_COUNT``) + +.. note:: + This API does not support capturing only a subset of the capture port's + channels, e.g. capturing only 3 channels on a 4-bit port. To accomplish this + the prefab API should be used. + +.. note:: + Though listed under Optional Configuration below, if the microphones are in + a DDR configuration and ``MIC_COUNT`` is not ``2``, the application must + also define ``MIC_ARRAY_CONFIG_USE_DDR``. + +``SAMPLES_PER_FRAME`` is the number of samples (for each microphone channel) +that will be delivered in each (non-overlapping) frame retrieved by +:cpp:func:`ma_frame_rx()`. A minimum value of ``1`` is supported, to deliver +samples one at a time. The larger this value, the looser the real-time +constraint on the thread receiving the mic array unit's output (while also +increasing the amount of audio data to be processed). + +Optional Configuration +---------------------- + +These are configuration parameters that receive default values but can be +optionally overridden by an application. These can be defined in your +application's ``CMakeLists.txt`` using CMake's built-in +``target_compile_definitions()`` command. + + +``MIC_ARRAY_CONFIG_USE_DDR`` + Indicates whether the microphones are arranged in an SDR (``0``) or DDR + (``1``) configuration. An SDR configuration is one in which each port pin is + connected to a single PDM microphone. A DDR configuration is one which each + port pin is connected to two PDM microphoes. Defaults to ``0`` (SDR), unless + ``MIC_ARRAY_CONFIG_MIC_COUNT`` is ``2`` in which case it defaults to ``1`` + (DDR). + + +``MIC_ARRAY_CONFIG_USE_DC_ELIMINATION`` + Indicates whether the :ref:`DC offset elmination ` filter + should be applied to the output of the decimator. Set to ``0`` to disable or + ``1`` to enable. Defaults to ``1`` (filter on). + +The next three parameters are the identifiers for hardware port resources used +by the mic array unit. They can be specified as either the identifier listed in +your device's datasheet (e.g. ``XS1_PORT_1D``) or as an alias fort he port +listed in your application's XN file (e.g. ``PORT_MCLK_IN_OUT``). For example: + +.. code-block:: xml + + ... + + ... + + ... + + ... + +``MIC_ARRAY_CONFIG_PORT_MCLK`` + Identifier of the 1-bit port on which the device is receiving the master audio + clock. Defaults to ``PORT_MCK_IN_OUT``. + + +``MIC_ARRAY_CONFIG_PORT_PDM_CLK`` + Identifier of the 1-bit port on which the device will signal the PDM clock to + the microphones. Defaults to ``PORT_PDM_CLK``. + +``MIC_ARRAY_CONFIG_PORT_PDM_DATA`` + Identifier of the port on which the device will capture PDM sample data. The + port width of this port must match the ``MIC_COUNT`` parameter given to + ``mic_array_vanilla_add()`` and the value of ``MIC_ARRAY_CONFIG_USE_DDR``. + Defaults to ``PORT_PDM_DATA``. + +The final two parameters indicate which clock block resource(s) should be used +to generate the PDM clock and the capture clock. An xcore.ai device provides 5 +hardware clock blocks for application use, identified as ``XS1_CLKBLK_1`` +through ``XS1_CLKBLK_5``. The device's clock blocks are interchangeable, but if +another component of your application uses one of these defaults, you may need +to change these parameters. + +``MIC_ARRAY_CONFIG_CLOCK_BLOCK_A`` + Clock block used as 'clock A' (see :ref:`getting_started`). This clock block + is used in both SDR and DDR configurations. + +``MIC_ARRAY_CONFIG_CLOCK_BLOCK_B`` + Clock block used as 'clock B' (see :ref:`getting_started`). This clock block + is only needed in DDR configurations and is ignored (not configured) in SDR + configurations. + + +Vanilla API with other Build Systems +------------------------------------ + +Using the Vanilla API with build systems other than CMake is simple. + +* Add the file ``etc/vanilla/mic_array_vanilla.cpp`` to the application's + source files. +* Add ``etc/vanilla/`` (relative to repository root) to the application include + paths. +* Add the compile definitions for the parameters listed in the previous sections + (each parameter beginning with ``MIC_ARRAY_CONFIG_``) to the compile options + for ``mic_array_vanilla.cpp``. \ No newline at end of file diff --git a/etc/vanilla/mic_array_vanilla.cpp b/etc/vanilla/mic_array_vanilla.cpp new file mode 100644 index 00000000..4f13955f --- /dev/null +++ b/etc/vanilla/mic_array_vanilla.cpp @@ -0,0 +1,123 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include + +#include "mic_array_vanilla.h" +#include "mic_array/cpp/Prefab.hpp" +#include "mic_array.h" +#include "mic_array/etc/filters_default.h" + + +////// Check that all the required config macros have been defined. + +#ifndef MIC_ARRAY_CONFIG_MCLK_FREQ +# error Application must specify the master clock frequency by defining MIC_ARRAY_CONFIG_MCLK_FREQ. +#endif + +#ifndef MIC_ARRAY_CONFIG_PDM_FREQ +# error Application must specify the PDM clock frequency by defining MIC_ARRAY_CONFIG_PDM_FREQ. +#endif + +#ifndef MIC_ARRAY_CONFIG_MIC_COUNT +# error Application must specify the microphone count by defining MIC_ARRAY_CONFIG_MIC_COUNT. +#endif + + +////// Provide default values for optional config macros + +#ifndef MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME +# define MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME (1) +#else +# if ((MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME) < 1) +# error MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME must be positive. +# endif +#endif + +#ifndef MIC_ARRAY_CONFIG_USE_DC_ELIMINATION +# define MIC_ARRAY_CONFIG_USE_DC_ELIMINATION (1) +#endif + +#ifndef MIC_ARRAY_CONFIG_PORT_MCLK +# define MIC_ARRAY_CONFIG_PORT_MCLK (PORT_MCLK_IN_OUT) +#endif + +#ifndef MIC_ARRAY_CONFIG_PORT_PDM_CLK +# define MIC_ARRAY_CONFIG_PORT_PDM_CLK (PORT_PDM_CLK) +#endif + +#ifndef MIC_ARRAY_CONFIG_PORT_PDM_DATA +# define MIC_ARRAY_CONFIG_PORT_PDM_DATA (PORT_PDM_DATA) +#endif + +#ifndef MIC_ARRAY_CONFIG_CLOCK_BLOCK_A +# define MIC_ARRAY_CONFIG_CLOCK_BLOCK_A (XS1_CLKBLK_1) +#endif + +#ifndef MIC_ARRAY_CONFIG_CLOCK_BLOCK_B +# define MIC_ARRAY_CONFIG_CLOCK_BLOCK_B (XS1_CLKBLK_2) +#endif + +#ifndef MIC_ARRAY_CONFIG_USE_DDR +# define MIC_ARRAY_CONFIG_USE_DDR ((MIC_ARRAY_CONFIG_MIC_COUNT)==2) +#endif + +////// Additional macros derived from others + +#define MIC_ARRAY_CONFIG_MCLK_DIVIDER ((MIC_ARRAY_CONFIG_MCLK_FREQ) \ + /(MIC_ARRAY_CONFIG_PDM_FREQ)) +#define MIC_ARRAY_CONFIG_OUT_SAMPLE_RATE ((MIC_ARRAY_CONFIG_PDM_FREQ) \ + /(STAGE2_DEC_FACTOR)) + +////// Any Additional correctness checks + + + +////// Allocate needed objects + +#if (!(MIC_ARRAY_CONFIG_USE_DDR)) +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_SDR( + MIC_ARRAY_CONFIG_PORT_MCLK, + MIC_ARRAY_CONFIG_PORT_PDM_CLK, + MIC_ARRAY_CONFIG_PORT_PDM_DATA, + MIC_ARRAY_CONFIG_CLOCK_BLOCK_A); +#else +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_DDR( + MIC_ARRAY_CONFIG_PORT_MCLK, + MIC_ARRAY_CONFIG_PORT_PDM_CLK, + MIC_ARRAY_CONFIG_PORT_PDM_DATA, + MIC_ARRAY_CONFIG_CLOCK_BLOCK_A, + MIC_ARRAY_CONFIG_CLOCK_BLOCK_B); +#endif + + + +using TMicArray = mic_array::prefab::BasicMicArray< + MIC_ARRAY_CONFIG_MIC_COUNT, + MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME, + MIC_ARRAY_CONFIG_USE_DC_ELIMINATION>; + +TMicArray mics; + + +void ma_vanilla_init() +{ + mics.Init(); + mics.SetPort(pdm_res.p_pdm_mics); + mic_array_resources_configure(&pdm_res, MIC_ARRAY_CONFIG_MCLK_DIVIDER); + mic_array_pdm_clock_start(&pdm_res); +} + + +void ma_vanilla_task( + chanend_t c_frames_out) +{ + mics.SetOutputChannel(c_frames_out); + + mics.InstallPdmRxISR(); + mics.UnmaskPdmRxISR(); + + mics.ThreadEntry(); +} \ No newline at end of file diff --git a/etc/vanilla/mic_array_vanilla.h b/etc/vanilla/mic_array_vanilla.h new file mode 100644 index 00000000..3ef5cf45 --- /dev/null +++ b/etc/vanilla/mic_array_vanilla.h @@ -0,0 +1,44 @@ +// Copyright 2022-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "mic_array.h" + + +C_API_START + +/** + * @brief Initializes the mic array module. (Vanilla API only) + * + * Initializes the contexts for the decimator thread and configures + * the clocks and ports for PDM reception. + * + * After calling this, the PDM clock is active and signaling, but the PDM rx + * service (ISR) has not yet been activated, so received PDM samples are + * ignored. The real-time condition is not yet active. + * + * @param pdm_res Hardware resources required by the mic array module. + */ +MA_C_API +void ma_vanilla_init(); + + +/** + * @brief Entry point for decimator thread and PDM rx. (Vanilla API only) + * + * This function sets up and activates the PDM rx service in ISR mode, and then + * immediately begins executing the decimator. + * + * After calling this the real-time condition is active, meaning there must be + * another thread waiting to pull frames from the other end of `c_frames_out` + * as they become available. + * + * @param c_frames_out (Non-streaming) Channel over which to send processed + * frames of audio. + */ +MA_C_API +void ma_vanilla_task(chanend_t c_frames_out); + + +C_API_END diff --git a/etc/vanilla/vanilla.cmake b/etc/vanilla/vanilla.cmake new file mode 100644 index 00000000..41e0cd40 --- /dev/null +++ b/etc/vanilla/vanilla.cmake @@ -0,0 +1,29 @@ + +function( mic_array_vanilla_add + TARGET_NAME + MCLK_FREQ + PDM_FREQ + MIC_COUNT + SAMPLES_PER_FRAME ) + + set( VANILLA_DIR "${CMAKE_CURRENT_FUNCTION_LIST_DIR}" ) + + target_sources( ${TARGET_NAME} + PRIVATE ${VANILLA_DIR}/mic_array_vanilla.cpp ) + + target_include_directories( ${TARGET_NAME} + PRIVATE ${VANILLA_DIR} ) + + target_compile_definitions( ${TARGET_NAME} + PRIVATE MIC_ARRAY_CONFIG_MCLK_FREQ=${MCLK_FREQ} ) + + target_compile_definitions( ${TARGET_NAME} + PRIVATE MIC_ARRAY_CONFIG_PDM_FREQ=${PDM_FREQ} ) + + target_compile_definitions( ${TARGET_NAME} + PRIVATE MIC_ARRAY_CONFIG_MIC_COUNT=${MIC_COUNT} ) + + target_compile_definitions( ${TARGET_NAME} + PRIVATE MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME=${SAMPLES_PER_FRAME} ) + +endfunction() \ No newline at end of file diff --git a/examples/AN00217_app_high_resolution_delay_example/.cproject b/examples/AN00217_app_high_resolution_delay_example/.cproject deleted file mode 100755 index a1e6cbf5..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/.cproject +++ /dev/null @@ -1,956 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/examples/AN00217_app_high_resolution_delay_example/.project b/examples/AN00217_app_high_resolution_delay_example/.project deleted file mode 100644 index 7c2cfd18..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - AN00217_app_high_resolution_delay_example - - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/examples/AN00217_app_high_resolution_delay_example/LICENSE.rst b/examples/AN00217_app_high_resolution_delay_example/LICENSE.rst deleted file mode 100644 index ca48f20f..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/LICENSE.rst +++ /dev/null @@ -1,84 +0,0 @@ -******************************* -XMOS PUBLIC LICENCE: Version 1 -******************************* - -Subject to the conditions and limitations below, permission is hereby granted by XMOS LIMITED (“XMOS”), free of charge, to any person or entity obtaining a copy of the XMOS Software. - -**1. Definitions** - -**“Applicable Patent Rights”** means: (a) where XMOS is the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to XMOS and (ii) that cover subject matter contained in the Software, but only to the extent it is necessary to use, reproduce or distribute the Software without infringement; and (b) where you are the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to you and (ii) that cover the subject matter contained in your Derivatives, taken alone or in combination with the Software. - -**“Compiled Code”** means any compiled, binary, machine readable or executable version of the Source Code. - -**“Contributor”** means any person or entity that creates or contributes to the creation of Derivatives. - -**“Derivatives”** means any addition to, deletion from and/or change to the substance, structure of the Software, any previous Derivatives, the combination of the Derivatives and the Software and/or any respective portions thereof. - -**“Source Code”** means the human readable code that is suitable for making modifications but excluding any Compiled Code. - -**“Software”** means the software and associated documentation files which XMOS makes available and which contain a notice identifying the software as original XMOS software and referring to the software being subject to the terms of this XMOS Public Licence. - -This Licence refers to XMOS Software and does not relate to any XMOS hardware or devices which are protected by intellectual property rights (including patent and trade marks) which may be sold to you under a separate agreement. - - -**2. Licence** - -**Permitted Uses, Conditions and Restrictions.** Subject to the conditions below, XMOS grants you a worldwide, royalty free, non-exclusive licence, to the extent of any Patent Rights to do the following: - -2.1 **Unmodified Software.** You may use, copy, display, publish, distribute and make available unmodified copies of the Software: - -2.1.1 for personal or academic, non-commercial purposes; or - -2.1.2 for commercial purposes provided the Software is at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.1.1 and 2.1.2): - -(a) you must retain and reproduce in all copies of the Software the copyright and proprietary notices and disclaimers of XMOS as they appear in the Software, and keep intact all notices and disclaimers in the Software files that refer to this Licence; and - -(b) you must include a copy of this Licence with every copy of the Software and documentation you publish, distribute and make available and you may not offer or impose any terms on such Software that alter or restrict this Licence or the intent of such Licence, except as permitted below (Additional Terms). - -The licence above does not include any Compiled Code which XMOS may make available under a separate support and licence agreement. - -2.2 **Derivatives.** You may create and modify Derivatives and use, copy, display, publish, distribute and make available Derivatives: - -2.2.1 for personal or academic, non-commercial purposes; or - -2.2.2 for commercial purposes, provided the Derivatives are at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.2.1 and 2.2.2): - -(a) you must comply with the terms of clause 2.1 with respect to the Derivatives; - -(b) you must copy (to the extent it doesn’t already exist) the notice below in each file of the Derivatives, and ensure all the modified files carry prominent notices stating that you have changed the files and the date of any change; and - -(c) if you sublicence, distribute or otherwise make the Software and/or the Derivatives available for commercial purposes, you must provide that the Software and Derivatives are at all times used on a device designed, licensed or developed by XMOS. - -Without limitation to these terms and clause 3 below, the Source Code and Compiled Code to your Derivatives may at your discretion (but without obligation) be released, copied, displayed, published, distributed and made available; and if you elect to do so, it must be under the terms of this Licence including the terms of the licence at clauses 2.2.1, 2.2.2 and clause 3 below. - -2.3 **Distribution of Executable Versions.** If you distribute or make available Derivatives, you must include a prominent notice in the code itself as well as in all related documentation, stating that the Source Code of the Software from which the Derivatives are based is available under the terms of this Licence, with information on how and where to obtain such Source Code. - -**3. Your Grant of Rights.** In consideration and as a condition to this Licence, you grant to any person or entity receiving or distributing any Derivatives, a non-exclusive, royalty free, perpetual, irrevocable license under your Applicable Patent Rights and all other intellectual property rights owned or controlled by you, to use, copy, display, publish, distribute and make available your Derivatives of the same scope and extent as XMOS’s licence under clause 2.2 above. - -**4. Combined Products.** You may create a combined product by combining Software, Derivatives and other code not covered by this Licence as a single application or product. In such instance, you must comply with the requirements of this Licence for any portion of the Software and/or Derivatives. - -**5. Additional Terms.** You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the term of this Licence (“Additional Terms”) to any legitimate recipients of the Software and/or Derivatives. The terms on which you provide such Additional Terms are on your sole responsibility and you shall indemnify, defend and hold XMOS harmless against any claims asserted against XMOS. - -**6. New Versions.** XMOS may publish revised and/or new versions of this Licence from time to time to accommodate changes to the Licence terms, new versions, updates and bug fixes of the Software. Each version will be given a distinguishing version number. Once Software has been published under a particular version of this Licence, you may continue to use it under the terms of that version. You may also choose to use the latest version of the Software under any subsequent version published by XMOS. Only XMOS shall have the right to modify these terms. - -**7. IPR and Ownership** -Any rights, including all intellectual property rights and all trademarks not expressly granted herein are reserved in full by the authors or copyright holders. Any requests for additional permissions by XMOS including any rights to use XMOS trademarks, should be made (without obligation) to XMOS at **support@xmos.com** - -Nothing herein shall limit any rights that XMOS is otherwise entitled to under the doctrines of patent exhaustion, implied license, or legal estoppel. Neither the name of the authors, the copyright holders or any contributors may be used to endorse or promote any Derivatives from this Software without specific written permission. Any attempt to deal with the Software which does not comply with this Licence shall be void and shall automatically terminate any rights granted under this licence (including any licence of any intellectual property rights granted herein). -Subject to the licences granted under this Licence any Contributor retains all rights, title and interest in and to any Derivatives made by Contributor subject to the underlying rights of XMOS in the Software. XMOS shall retain all rights, title and interest in the Software and any Derivatives made by XMOS (“XMOS Derivatives”). XMOS Derivatives will not automatically be subject to this Licence and XMOS shall be entitled to licence such rights on any terms (without obligation) as it sees fit. - -**8. Termination** - -8.1 This Licence will automatically terminate immediately, without notice to you, if: - -(a) you fail to comply with the terms of this Licence; and/or - -(b) you directly or indirectly commence any action for patent or intellectual property right infringement against XMOS, or any parent, group, affiliate or subsidiary of XMOS; provided XMOS did not first commence an action or patent infringement against you in that instance; and/or - -(c) the terms of this Licence are held by any court of competent jurisdiction to be unenforceable in whole or in part. - -**9. Critical Applications.** Unless XMOS has agreed in writing with you an agreement specifically governing use of the Goods in military, aerospace, automotive or medically related functions (collectively and individually hereinafter referred to as "Special Use"), any permitted use of the Software excludes Special Use. Notwithstanding any agreement between XMOS and you for Special Use, Special Use shall be at your own risk, and you shall fully indemnify XMOS against any damages, losses, costs and claims (direct and indirect) arising out of any Special Use. - -**10. NO WARRANTY OR SUPPORT.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL XMOS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, WARRANTY, CIVIL TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE INCLUDING GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES EVEN IF SUCH PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOT WITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE. IN SOME JURISDICTIONS PARTIES ARE UNABLE TO LIMIT LIABILTY IN THIS WAY, IF THIS APPLIES TO YOUR JURISDICTION THIS LIABILITY CLAUSE ABOVE MAY NOT APPLY. NOTWITHSTANDING THE ABOVE, IN NO EVENT SHALL XMOS’s TOTAL LIABILITY TO YOU FOR ALL DAMAGES, LOSS OR OTHERWISE EXCEED $50. - -**11. Governing Law and Jurisdiction.** This Licence constitutes the entire agreement between the parties with respect to the subject matter hereof. The Licence shall be governed by the laws of England and the conflict of laws and UN Convention on Contracts for the International Sale of Goods, shall not apply. diff --git a/examples/AN00217_app_high_resolution_delay_example/MIC-ARRAY-1V0.xn b/examples/AN00217_app_high_resolution_delay_example/MIC-ARRAY-1V0.xn deleted file mode 100644 index e8efb894..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/MIC-ARRAY-1V0.xn +++ /dev/null @@ -1,115 +0,0 @@ - - - Board - XS2 MC Audio - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00217_app_high_resolution_delay_example/Makefile b/examples/AN00217_app_high_resolution_delay_example/Makefile deleted file mode 100644 index d5f730ac..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = MIC-ARRAY-1V0 - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = app_high_resolution_delay_example - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array(>=3.0.0) - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/examples/AN00217_app_high_resolution_delay_example/README.rst b/examples/AN00217_app_high_resolution_delay_example/README.rst deleted file mode 100644 index deb4dbfa..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/README.rst +++ /dev/null @@ -1,33 +0,0 @@ -High Resolution Delay Example -============================= - -Summary -------- - -This example demonstrates how to use the microphone array library with the high resolution delay lines -to capture samples from the microphone array. The example is designed to show up to 8 channel array processing. - -Software dependencies -..................... - -For a list of direct dependencies, look for USED_MODULES in the Makefile. - -Required hardware -................. - -This is an example only with no hardware requirements. - -Prerequisites -............. - - * This document assumes familiarity with the XMOS xCORE architecture, - the XMOS tool chain and the xC language. Documentation related to these - aspects which are not specific to this application note are linked to in - the references appendix. - - * The ``lib_mic_array`` user guide should be thoroughly read and understood. - - * For a description of XMOS related terms found in this document - please see the XMOS Glossary [#]_. - -.. [#] http://www.xmos.com/published/glossary diff --git a/examples/AN00217_app_high_resolution_delay_example/doc/rst/AN00217.rst b/examples/AN00217_app_high_resolution_delay_example/doc/rst/AN00217.rst deleted file mode 100644 index 5073fa8c..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/doc/rst/AN00217.rst +++ /dev/null @@ -1,248 +0,0 @@ -.. include:: ../../README.rst - -|newpage| - -Overview --------- - -Introduction -............ - -This demo application shows the minimum code required to setup the microphone array. It outlines -configuring the decimators and illustrates task structure. - -Block diagram -............. - -.. figure:: block_diagram.pdf - :width: 80% - - Application block diagram - -How to use lib_mic_array ------------------------- - -The Makefile -............ - -To start using the microphone array library with high resolution delay lines, you need to -add ``lib_mic_array`` to you Makefile:: - - USED_MODULES = .. lib_mic_array ... - -Includes -........ - -This application requires the system headers that defines XMOS xCORE specific -defines for declaring and initialising hardware: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: include - :end-on: include - -The microphone array library functions are defined in ``lib_mic_array.h``. This header must -be included in your code to use the library. The support functions for the board are defined in -``mic_array_board_support.h`` and the logging functions are provided by ``debug_print.h``. - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: include "mic_array.h" - :end-before: in port p_pdm_clk - -Allocating hardware resources -............................. - -A PDM microphone requires a clock and a data pin. For eight PDM microphones a single -clock can be shared between all microphones and the data can be sampled on a single -8 bit port. On an xCORE the pins are controlled by ``ports``. The application therefore -declares one 1-bit port and one 8-bit port: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: in port p_pdm_clk - :end-on: in buffered port:32 p_pdm_mics - -To generate the PDM clock a 24.576MHz master clock is divided by 8 using a clock block. These two hardware -resources are declared with: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: in port p_mclk - :end-on: clock pdmclk - -and are configured with: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: configure_clock_src_divide(pdmclk - :end-on: start_clock(pdmclk); - -The result begin a 3.072MHz PDM clock is used for clocking the microphone data into the xCORE. - - -Task setup ----------- - -The PDM microphones interface task, high resolution delay task and the decimators have to be connected -together and to the application (``example()``). There needs to be one -``mic_array_decimate_to_pcm_4ch()`` task per four channels that need processing. -There needs to be only one ``mic_array_hires_delay`` task for up to 16 channels. -The PDM interface task, ``mic_array_pdm_rx()`` can process eight channels so only -one is needed for this application. The PDM interface needs to be connected to the -high resolution interface via two streaming channels and connected to the two -decimators via streaming channels. Finally, the decimators have to be connected to -the application. - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: streaming chan c_pdm_to_hires - :end-before: return 0; - -Note that the decimators have to be on the same tile as the application due to shared frame memory. -Also, there needs to be a channel between the ``mic_array_hires_delay`` and the application in -order to issue the commands to change the taps on each delay line. - -Frame memory ------------- - -For each decimator an block of memory must be allocated for storing FIR data. The size of the data -block must be:: - - Number of channels for that decimator * THIRD_STAGE_COEFS_PER_STAGE * Decimation factor * sizeof(int) - -bytes. The data must also be double word aligned. For example: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: int data[ - :end-before: void example - -Note that on the xCORE-200 all global arrays are guaranteed to be double-word aligned. - -Configuration -------------- - -Configuration of the microphone array for the example is achieved through: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: mic_array_decimator_conf_common_t dcc - :end-before: mic_array_init_time_domain_frame - -All configuration options are described in the Microphone array library guide. Once configured -then the decimators require initialization via: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: mic_array_init_time_domain_frame - :end-before: while(1) - -The decimators will start presenting samples in the form of frames that can be accessed with: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: mic_array_frame_time_domain * current = - :end-on: mic_array_get_next_time_domain_frame - -The return value of ``mic_array_get_next_time_domain_frame()`` is a pointer to the frame that -the application is allowed to access. The ``current`` frame contains the frame data in the -``data`` member. ``data`` is a 2D array with the first index denoting the channel number and -the second index denoting the frame index. The frame index used 0 for the oldest samples and -increasing indices for newer samples. - -Changing the sample rate -........................ - -The sample rate chane be change easily with the example code by modifying: - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: #define DECIMATION_FACTOR - :end-before: #define DECIMATOR_COUNT - -The supported ``DECIMATION_FACTORS`` that come as standard from ``lib_mic_array`` are 2, 4, 6, 8 and 12. These -correspond to 48kHz, 24kHz, 16kHz, 12kHz, 8kHz and 6kHz. In order to change the define successfully you must -also ensure that the coefficients to the decimators are correct for the selected decimation factor. -The coefficients are declared in the header ``fir_coefs.h`` which is included in ``mic_array.h``. The ``coefs`` -member of ``mic_array_decimator_config_common`` must match the ``output_decimation_factor`` member. Also, -the FIR compensation must be made to match. For example, to change to 24kHz output, the config should look like:: - - mic_array_decimator_config_common dcc = { - 0, // Frame size log 2 is set to 0, i.e. one sample per channel will be present in each frame - 1, // DC offset elimination is turned on - 0, // Index bit reversal is off - 0, // No windowing function is being applied - 4,// The decimation factor is set to 6 - g_third_stage_div_4_fir, // This corresponds to a 24kHz output hence this coef array is used - 0, // Gain compensation is turned off - FIR_COMPENSATOR_DIV_4, // FIR compensation is set to the corresponding coefficients - DECIMATOR_NO_FRAME_OVERLAP, // Frame overlapping is turned off - FRAME_BUFFER_COUNT // The number of buffers in the audio array - }; - -Changing the frame buffer count -............................... - -The number of frame buffer in use can be modified through the define - -.. literalinclude:: app_high_resolution_delay_example.xc - :start-on: #define FRAME_BUFFER_COUNT 2 - :end-before: #define DECIMATOR_CH_COUNT 4 - -within this application. Increasing this would allow sample to be known for a longer period of time -before the memory is reused for the present samples at the cost of increased memory usage. - - -Changing the frame size -....................... - -The length of a frame is an arbitrary value < 2**15. The maximum allowed at run time is given by two to the -power of ``MIC_ARRAY_MAX_FRAME_SIZE_LOG2``. At run time the length can be dynamically configured by -setting the ``len`` member of ``mic_array_decimator_config_common``. If ``len`` -is less than 16, the frame size will be ``2^len``. If ``len`` is 16 or greater, the -frame size will be ``len``. - -Changing the buffering type -........................... - -The buffering type can be either ``DECIMATOR_NO_FRAME_OVERLAP`` or ``DECIMATOR_HALF_FRAME_OVERLAP``. -This is configured through the ``buffering_type`` member of ``mic_array_decimator_config_common``. -In half frame overlap mode the rate that the ``mic_array_get_next_time_domain_frame()`` function must -be serviced is doubled. - -Disabling the DC offset elimination -................................... - -The DC offset elimination can be disabled by configuring the ``mic_array_decimator_config_common`` with -0 in the ``apply_dc_offset_removal`` member. Setting ``apply_dc_offset_removal`` to non-zero will enable -it. - -Enabling microphone gain compensation -..................................... - -To enable the microphone gain compensation first the ``apply_mic_gain_compensation`` member of -``mic_array_decimator_config_common`` must be set to non-zero. Then for each ``mic_array_decimator_config`` -structure used to configure a 4 channel decimator the array member ``mic_gain_compensation`` must be set. -If the gain a microphone i is g\ :sub:`i`\, then the compensation factor should be -``INT_MAX`` / min(g\ :sub:`i`\) for each microphone i. - -References ----------- - -.. nopoints:: - - * XMOS Tools User Guide - - http://www.xmos.com/published/xtimecomposer-user-guide - - * XMOS xCORE Programming Guide - - http://www.xmos.com/published/xmos-programming-guide - - * XMOS Microphone Array Library - - http://www.xmos.com/support/libraries/lib_mic_array - - -|newpage| - -Full source code listing ------------------------- - -Source code for app_high_resolution_delay_example.xc -.................................................... - -.. literalinclude:: app_high_resolution_delay_example.xc - :largelisting: - -|newpage| diff --git a/examples/AN00217_app_high_resolution_delay_example/doc/rst/block_diagram.dot b/examples/AN00217_app_high_resolution_delay_example/doc/rst/block_diagram.dot deleted file mode 100644 index 46c299ad..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/doc/rst/block_diagram.dot +++ /dev/null @@ -1,19 +0,0 @@ -digraph g { - - mic_array_pdm_rx [label="mic_array_pdm_rx()", color=red]; - mic_array_hires_delay [label="mic_array_hires_delay()", color=red]; - mic_array_decimate_to_pcm_4ch1 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - mic_array_decimate_to_pcm_4ch0 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - example [label="example()", color=red]; - - pdm_mic [label="PDM Microphone", shape=box]; - - pdm_mic -> mic_array_pdm_rx; - - mic_array_pdm_rx -> mic_array_hires_delay; - mic_array_hires_delay -> mic_array_decimate_to_pcm_4ch0; - mic_array_hires_delay -> mic_array_decimate_to_pcm_4ch1; - - mic_array_decimate_to_pcm_4ch0 -> example; - mic_array_decimate_to_pcm_4ch1 -> example; -} \ No newline at end of file diff --git a/examples/AN00217_app_high_resolution_delay_example/doc/rst/block_diagram.pdf b/examples/AN00217_app_high_resolution_delay_example/doc/rst/block_diagram.pdf deleted file mode 100644 index 1f9a887c..00000000 Binary files a/examples/AN00217_app_high_resolution_delay_example/doc/rst/block_diagram.pdf and /dev/null differ diff --git a/examples/AN00217_app_high_resolution_delay_example/doc/rst/xdoc.conf b/examples/AN00217_app_high_resolution_delay_example/doc/rst/xdoc.conf deleted file mode 100644 index 37460abf..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/doc/rst/xdoc.conf +++ /dev/null @@ -1,2 +0,0 @@ -XMOSNEWSTYLE=1 -SOURCE_INCLUDE_DIRS=../../src \ No newline at end of file diff --git a/examples/AN00217_app_high_resolution_delay_example/src/app_high_resolution_delay_example.xc b/examples/AN00217_app_high_resolution_delay_example/src/app_high_resolution_delay_example.xc deleted file mode 100644 index 37d384a4..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/src/app_high_resolution_delay_example.xc +++ /dev/null @@ -1,95 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include - -#include "mic_array.h" - -on tile[0]: out port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -#define DECIMATION_FACTOR 6 //Corresponds to a 16kHz output sample rate -#define DECIMATOR_COUNT 2 //8 channels requires 2 decimators -#define FRAME_BUFFER_COUNT 2 //The minimum of 2 will suffice for this example - -#define DECIMATOR_CH_COUNT 4 //Just to be clear - -int data[DECIMATOR_COUNT*DECIMATOR_CH_COUNT] - [THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR]; - -void example(streaming chanend c_ds_output[DECIMATOR_COUNT], streaming chanend c_cmd) { - unsafe{ - mic_array_frame_time_domain audio[FRAME_BUFFER_COUNT]; - - unsigned buffer; //No need to initialize this. - memset(data, 0, DECIMATOR_COUNT*DECIMATOR_CH_COUNT* - THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR*sizeof(int)); - - mic_array_decimator_conf_common_t dcc = { - 0, // Frame size log 2 is set to 0, i.e. one sample per channel will be present in each frame - 1, // DC offset elimination is turned on - 0, // Index bit reversal is off - 0, // No windowing function is being applied - DECIMATION_FACTOR,// The decimation factor is set to 6 - g_third_stage_div_6_fir, // This corresponds to a 16kHz output hence this coef array is used - 0, // Gain compensation is turned off - FIR_COMPENSATOR_DIV_6, // FIR compensation is set to the corresponding coefficients - DECIMATOR_NO_FRAME_OVERLAP, // Frame overlapping is turned off - FRAME_BUFFER_COUNT // The number of buffers in the audio array - }; - - mic_array_decimator_config_t dc[DECIMATOR_COUNT] = { - { - &dcc, - data[0], // The storage area for the output decimator - {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, // Microphone gain compensation (turned off) - 4, // Enabled channel count (currently must be 4) - 0, // Disable async interface - }, - { - &dcc, - data[4], // The storage area for the output decimator - {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, // Microphone gain compensation (turned off) - 4, // Enabled channel count (currently must be 4) - 0, // Disable async interface - } - }; - mic_array_decimator_configure(c_ds_output, DECIMATOR_COUNT, dc); - - mic_array_init_time_domain_frame(c_ds_output, DECIMATOR_COUNT, buffer, audio, dc); - - while(1){ - mic_array_frame_time_domain * current = - mic_array_get_next_time_domain_frame(c_ds_output, DECIMATOR_COUNT, buffer, audio, dc); - - // Update the delays. Delay values must be in range 0..HIRES_MAX_DELAY - unsigned delays[7] = {0, 1, 2, 3, 4, 5, 6}; - mic_array_hires_delay_set_taps(c_cmd, delays, 7); - } - } -} - -int main() { - configure_clock_src_divide(pdmclk, p_mclk, 4); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - streaming chan c_pdm_to_hires[DECIMATOR_COUNT]; - streaming chan c_hires_to_dec[DECIMATOR_COUNT]; - streaming chan c_ds_output[DECIMATOR_COUNT]; - streaming chan c_cmd; - - par { - mic_array_pdm_rx(p_pdm_mics, c_pdm_to_hires[0], c_pdm_to_hires[1]); - mic_array_hires_delay(c_pdm_to_hires, c_hires_to_dec, 2, c_cmd); - mic_array_decimate_to_pcm_4ch(c_hires_to_dec[0], c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_hires_to_dec[1], c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - example(c_ds_output, c_cmd); - } - - return 0; -} diff --git a/examples/AN00217_app_high_resolution_delay_example/src/mic_array_conf.h b/examples/AN00217_app_high_resolution_delay_example/src/mic_array_conf.h deleted file mode 100644 index 6ed389be..00000000 --- a/examples/AN00217_app_high_resolution_delay_example/src/mic_array_conf.h +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 8 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/examples/AN00218_app_hires_DAS_fixed/.cproject b/examples/AN00218_app_hires_DAS_fixed/.cproject deleted file mode 100644 index ced59933..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/.cproject +++ /dev/null @@ -1,1031 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/examples/AN00218_app_hires_DAS_fixed/.project b/examples/AN00218_app_hires_DAS_fixed/.project deleted file mode 100644 index f451e6cb..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - AN00218_app_hires_DAS_fixed - - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/examples/AN00218_app_hires_DAS_fixed/LICENSE.rst b/examples/AN00218_app_hires_DAS_fixed/LICENSE.rst deleted file mode 100644 index ca48f20f..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/LICENSE.rst +++ /dev/null @@ -1,84 +0,0 @@ -******************************* -XMOS PUBLIC LICENCE: Version 1 -******************************* - -Subject to the conditions and limitations below, permission is hereby granted by XMOS LIMITED (“XMOS”), free of charge, to any person or entity obtaining a copy of the XMOS Software. - -**1. Definitions** - -**“Applicable Patent Rights”** means: (a) where XMOS is the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to XMOS and (ii) that cover subject matter contained in the Software, but only to the extent it is necessary to use, reproduce or distribute the Software without infringement; and (b) where you are the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to you and (ii) that cover the subject matter contained in your Derivatives, taken alone or in combination with the Software. - -**“Compiled Code”** means any compiled, binary, machine readable or executable version of the Source Code. - -**“Contributor”** means any person or entity that creates or contributes to the creation of Derivatives. - -**“Derivatives”** means any addition to, deletion from and/or change to the substance, structure of the Software, any previous Derivatives, the combination of the Derivatives and the Software and/or any respective portions thereof. - -**“Source Code”** means the human readable code that is suitable for making modifications but excluding any Compiled Code. - -**“Software”** means the software and associated documentation files which XMOS makes available and which contain a notice identifying the software as original XMOS software and referring to the software being subject to the terms of this XMOS Public Licence. - -This Licence refers to XMOS Software and does not relate to any XMOS hardware or devices which are protected by intellectual property rights (including patent and trade marks) which may be sold to you under a separate agreement. - - -**2. Licence** - -**Permitted Uses, Conditions and Restrictions.** Subject to the conditions below, XMOS grants you a worldwide, royalty free, non-exclusive licence, to the extent of any Patent Rights to do the following: - -2.1 **Unmodified Software.** You may use, copy, display, publish, distribute and make available unmodified copies of the Software: - -2.1.1 for personal or academic, non-commercial purposes; or - -2.1.2 for commercial purposes provided the Software is at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.1.1 and 2.1.2): - -(a) you must retain and reproduce in all copies of the Software the copyright and proprietary notices and disclaimers of XMOS as they appear in the Software, and keep intact all notices and disclaimers in the Software files that refer to this Licence; and - -(b) you must include a copy of this Licence with every copy of the Software and documentation you publish, distribute and make available and you may not offer or impose any terms on such Software that alter or restrict this Licence or the intent of such Licence, except as permitted below (Additional Terms). - -The licence above does not include any Compiled Code which XMOS may make available under a separate support and licence agreement. - -2.2 **Derivatives.** You may create and modify Derivatives and use, copy, display, publish, distribute and make available Derivatives: - -2.2.1 for personal or academic, non-commercial purposes; or - -2.2.2 for commercial purposes, provided the Derivatives are at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.2.1 and 2.2.2): - -(a) you must comply with the terms of clause 2.1 with respect to the Derivatives; - -(b) you must copy (to the extent it doesn’t already exist) the notice below in each file of the Derivatives, and ensure all the modified files carry prominent notices stating that you have changed the files and the date of any change; and - -(c) if you sublicence, distribute or otherwise make the Software and/or the Derivatives available for commercial purposes, you must provide that the Software and Derivatives are at all times used on a device designed, licensed or developed by XMOS. - -Without limitation to these terms and clause 3 below, the Source Code and Compiled Code to your Derivatives may at your discretion (but without obligation) be released, copied, displayed, published, distributed and made available; and if you elect to do so, it must be under the terms of this Licence including the terms of the licence at clauses 2.2.1, 2.2.2 and clause 3 below. - -2.3 **Distribution of Executable Versions.** If you distribute or make available Derivatives, you must include a prominent notice in the code itself as well as in all related documentation, stating that the Source Code of the Software from which the Derivatives are based is available under the terms of this Licence, with information on how and where to obtain such Source Code. - -**3. Your Grant of Rights.** In consideration and as a condition to this Licence, you grant to any person or entity receiving or distributing any Derivatives, a non-exclusive, royalty free, perpetual, irrevocable license under your Applicable Patent Rights and all other intellectual property rights owned or controlled by you, to use, copy, display, publish, distribute and make available your Derivatives of the same scope and extent as XMOS’s licence under clause 2.2 above. - -**4. Combined Products.** You may create a combined product by combining Software, Derivatives and other code not covered by this Licence as a single application or product. In such instance, you must comply with the requirements of this Licence for any portion of the Software and/or Derivatives. - -**5. Additional Terms.** You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the term of this Licence (“Additional Terms”) to any legitimate recipients of the Software and/or Derivatives. The terms on which you provide such Additional Terms are on your sole responsibility and you shall indemnify, defend and hold XMOS harmless against any claims asserted against XMOS. - -**6. New Versions.** XMOS may publish revised and/or new versions of this Licence from time to time to accommodate changes to the Licence terms, new versions, updates and bug fixes of the Software. Each version will be given a distinguishing version number. Once Software has been published under a particular version of this Licence, you may continue to use it under the terms of that version. You may also choose to use the latest version of the Software under any subsequent version published by XMOS. Only XMOS shall have the right to modify these terms. - -**7. IPR and Ownership** -Any rights, including all intellectual property rights and all trademarks not expressly granted herein are reserved in full by the authors or copyright holders. Any requests for additional permissions by XMOS including any rights to use XMOS trademarks, should be made (without obligation) to XMOS at **support@xmos.com** - -Nothing herein shall limit any rights that XMOS is otherwise entitled to under the doctrines of patent exhaustion, implied license, or legal estoppel. Neither the name of the authors, the copyright holders or any contributors may be used to endorse or promote any Derivatives from this Software without specific written permission. Any attempt to deal with the Software which does not comply with this Licence shall be void and shall automatically terminate any rights granted under this licence (including any licence of any intellectual property rights granted herein). -Subject to the licences granted under this Licence any Contributor retains all rights, title and interest in and to any Derivatives made by Contributor subject to the underlying rights of XMOS in the Software. XMOS shall retain all rights, title and interest in the Software and any Derivatives made by XMOS (“XMOS Derivatives”). XMOS Derivatives will not automatically be subject to this Licence and XMOS shall be entitled to licence such rights on any terms (without obligation) as it sees fit. - -**8. Termination** - -8.1 This Licence will automatically terminate immediately, without notice to you, if: - -(a) you fail to comply with the terms of this Licence; and/or - -(b) you directly or indirectly commence any action for patent or intellectual property right infringement against XMOS, or any parent, group, affiliate or subsidiary of XMOS; provided XMOS did not first commence an action or patent infringement against you in that instance; and/or - -(c) the terms of this Licence are held by any court of competent jurisdiction to be unenforceable in whole or in part. - -**9. Critical Applications.** Unless XMOS has agreed in writing with you an agreement specifically governing use of the Goods in military, aerospace, automotive or medically related functions (collectively and individually hereinafter referred to as "Special Use"), any permitted use of the Software excludes Special Use. Notwithstanding any agreement between XMOS and you for Special Use, Special Use shall be at your own risk, and you shall fully indemnify XMOS against any damages, losses, costs and claims (direct and indirect) arising out of any Special Use. - -**10. NO WARRANTY OR SUPPORT.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL XMOS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, WARRANTY, CIVIL TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE INCLUDING GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES EVEN IF SUCH PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOT WITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE. IN SOME JURISDICTIONS PARTIES ARE UNABLE TO LIMIT LIABILTY IN THIS WAY, IF THIS APPLIES TO YOUR JURISDICTION THIS LIABILITY CLAUSE ABOVE MAY NOT APPLY. NOTWITHSTANDING THE ABOVE, IN NO EVENT SHALL XMOS’s TOTAL LIABILITY TO YOU FOR ALL DAMAGES, LOSS OR OTHERWISE EXCEED $50. - -**11. Governing Law and Jurisdiction.** This Licence constitutes the entire agreement between the parties with respect to the subject matter hereof. The Licence shall be governed by the laws of England and the conflict of laws and UN Convention on Contracts for the International Sale of Goods, shall not apply. diff --git a/examples/AN00218_app_hires_DAS_fixed/MIC-ARRAY-1V0.xn b/examples/AN00218_app_hires_DAS_fixed/MIC-ARRAY-1V0.xn deleted file mode 100644 index e8efb894..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/MIC-ARRAY-1V0.xn +++ /dev/null @@ -1,115 +0,0 @@ - - - Board - XS2 MC Audio - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00218_app_hires_DAS_fixed/Makefile b/examples/AN00218_app_hires_DAS_fixed/Makefile deleted file mode 100644 index 940aaa27..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = MIC-ARRAY-1V0 - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = app_hires_DAS_fixed - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_i2c(>=4.0.0) lib_i2s(>=2.2.0) lib_mic_array(>=3.0.0) lib_mic_array_board_support(>=2.1.0) - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g -DDEBUG_PRINT_ENABLE=1 - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/examples/AN00218_app_hires_DAS_fixed/README.rst b/examples/AN00218_app_hires_DAS_fixed/README.rst deleted file mode 100644 index 295b77d6..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/README.rst +++ /dev/null @@ -1,36 +0,0 @@ -.. |I2S| replace:: I\ :sup:`2`\ S -.. |I2C| replace:: I\ :sup:`2`\ C - -High Resolution Delay and Sum -============================= - -Summary -------- - -Software dependencies -..................... - -For a list of direct dependencies, look for USED_MODULES in the Makefile. - -Required hardware -................. - -The example code provided with the application has been implemented -and tested on the Microphone Array Ref Design v1. - -Prerequisites -............. - - * This document assumes familiarity with the XMOS xCORE architecture, - the XMOS tool chain and the xC language. Documentation related to these - aspects which are not specific to this application note are linked to in - the references appendix. - - * The ``lib_mic_array`` user guide should be thoroughly read and understood. - - * For a description of XMOS related terms found in this document - please see the XMOS Glossary [#]_. - -.. [#] http://www.xmos.com/published/glossary - - diff --git a/examples/AN00218_app_hires_DAS_fixed/config.xscope b/examples/AN00218_app_hires_DAS_fixed/config.xscope deleted file mode 100644 index 65c87678..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/config.xscope +++ /dev/null @@ -1,29 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00218_app_hires_DAS_fixed/doc/rst/AN00218.rst b/examples/AN00218_app_hires_DAS_fixed/doc/rst/AN00218.rst deleted file mode 100644 index 7df7c62a..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/doc/rst/AN00218.rst +++ /dev/null @@ -1,282 +0,0 @@ -.. include:: ../../README.rst - -|newpage| - -Overview --------- - -Introduction -............ - -This demo application shows a simple Delay and Sum (DAS) beamformer in high resolution mode. -It shows the setup of the |I2S| for audio output via the DAC and very simple processing of -multi-channel audio frames to produce a single channel output based on a simple single steering direction. - -Block diagram -............. - -.. figure:: block_diagram.pdf - :width: 80% - - Application block diagram - -How to use lib_mic_array with high resolution delay lines ---------------------------------------------------------- - -The Makefile -............ - -To start using the microphone array library with high resolution delay lines, you need to add ``lib_mic_array`` to you Makefile:: - - USED_MODULES = .. lib_mic_array ... - -This demo also uses the logging library (``lib_logging``) for the ``debug_printf`` -function. This is a faster, but more limited version of the C-Standard Library -``printf`` function. So the Makefile also includes:: - - USED_MODULES = .. lib_logging .. - -The logging library is configurable at compile-time allowing calls to -``debug_printf()`` to be easily enabled or disabled. For the prints to -be enabled it is necessary to add the following to the compile flags:: - - XCC_FLAGS = .. -DDEBUG_PRINT_ENABLE=1 .. - -Includes -........ - -This application requires the system headers that defines XMOS xCORE specific -defines for declaring and initialising hardware: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: include - :end-on: include - -The microphone array library functions are defined in ``lib_mic_array.h``. This header must -be included in your code to use the library. The support functions for the board are defined in -``mic_array_board_support.h`` and the logging functions are provided by ``debug_print.h``. - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: include "mic_array.h" - :end-on: include "debug_print.h" - -Also required is support for |I2S| and |I2C| through the headers: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: include "i2c.h" - :end-on: include "i2s.h" - -Allocating hardware resources -............................. - -A PDM microphone requires a clock and a data pin. For eight PDM microphones a single -clock can be shared between all microphones and the data can be sampled on a single -8 bit port. On an xCORE the pins are controlled by ``ports``. The application therefore -declares one 1-bit port and one 8-bit port: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: in port p_pdm_clk - :end-on: in buffered port:32 p_pdm_mics - -To generate the PDM clock a 24.576MHz master clock is divided by 8 using a clock block. These two hardware -resources are declared with: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: in port p_mclk - :end-on: clock pdmclk - -and are configured with: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: configure_clock_src_divide(pdmclk - :end-on: start_clock(pdmclk); - -The result begin a 3.072MHz PDM clock is used for clocking the microphone data into the xCORE. Additionally, -the LEDs and buttons are declared by - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: p_leds leds - :end-on: in port p_buttons - -And the |I2S| is declared with: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: p_i2s_dout[1] - :end-on: clock bclk - -Demo Hardware Setup -------------------- - -To run the demo, connect a USB cable to power the Microphone Array Ref Design v1 -and plug the xTAG to the board and connect the xTAG USB cable to your -development machine. You will also need to connect headphones to the audio jack. - - -.. figure:: setup.jpg - :width: 80% - - Hardware setup - -|newpage| - -Launching the demo application ------------------------------- - -Once the demo example has been built either from the command line using xmake or -via the build mechanism of xTIMEcomposer studio it can be executed on the Microphone Array Ref Design v1. - -Once built there will be a ``bin/`` directory within the project which contains -the binary for the xCORE device. The xCORE binary has a XMOS standard .xe extension. - -Launching from the command line -............................... - -From the command line you use the ``xrun`` tool to download and run the code -on the xCORE device:: - - xrun --xscope bin/app_hires_DAS_fixed.xe - -Once this command has executed the application will be running on the -Microphone Array Ref Design v1. - -Launching from xTIMEcomposer Studio -................................... - -From xTIMEcomposer Studio use the run mechanism to download code to xCORE device. -Select the xCORE binary from the ``bin/`` directory, right click and go to Run -Configurations. Double click on xCORE application to create a new run configuration, -enable the xSCOPE I/O mode in the dialog box and then -select Run. - -Once this command has executed the application will be running on the -Microphone Array Ref Design v1. - -Running the application -....................... - -Once the application is started using either of the above methods there will -be the output of the microphones through the headphones. - -Buttons ``A`` and ``D`` rotate the direction of the beam which is indicated by the LEDs. -Buttons ``B`` and ``C`` decrease and increase the gain on the output signal respectively. - -|newpage| - -Task setup ----------- - -The PDM microphones interface task, high resolution delay task and the decimators have to be connected -together and to the application (``hires_DAS_fixed()``). There needs to be one -``mic_array_decimate_to_pcm_4ch()`` task per four channels that need processing. -There needs to be only one ``mic_array_hires_delay`` task for up to 16 channels. -The PDM interface task, ``mic_array_pdm_rx()`` can process eight channels so only -one is needed for this application. The PDM interface needs to be connected to the -high resolution interface via two streaming channels and connected to the two -decimators via streaming channels. Finally, the decimators have to be connected to -the application. - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: streaming chan c_4x_pdm_mic - :end-before: return 0; - -Note that the decimators have to be on the same tile as the application due to shared frame memory. -Also, there needs to be a channel between the ``mic_array_hires_delay`` and the application in -order to issue the commands to change the taps on each delay line. - -Frame memory ------------- - -For each decimator an block of memory must be allocated for storing FIR data. The size of the data -block must be:: - - Number of channels for that decimator * THIRD_STAGE_COEFS_PER_STAGE * Decimation factor * sizeof(int) - -bytes. The data must also be double word aligned. For example: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: int data[8] - :end-before: void hires_DAS_fixed - -Note that on the xCORE-200 all global arrays are guaranteed to be double-word aligned. - -Configuration -------------- - -Configuration of the microphone array for the example is achieved through: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: mic_array_decimator_conf_common_t dcc = - :end-before: mic_array_init_time_domain_frame - -All configuration options are described in the Microphone array library guide. Once configured -then the decimators require initialization via: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: mic_array_init_time_domain_frame - :end-before: while(1) - -The decimators will start presenting samples in the form of frames that can be accessed with: - -.. literalinclude:: app_hires_DAS_fixed.xc - :start-on: mic_array_frame_time_domain * current = - :end-on: mic_array_get_next_time_domain_frame - -The return value of ``mic_array_get_next_time_domain_frame()`` is a pointer to the frame that -the application is allowed to access. The ``current`` frame contains the frame data in the -``data`` member. ``data`` is a 2D array with the first index denoting the channel number and -the second index denoting the frame index. The frame index used 0 for the oldest samples and -increasing indices for newer samples. - -Updating the delays -------------------- - -The high resolution delay task is initially set to delay all channels by a zero 384kHz clock cycles. Each channel can -be delayed by up to ``MIC_ARRAY_HIRES_MAX_DELAY`` (default 256) samples at a sample rate of 384kHz. Setting of the taps -is done through the function ``mic_array_hires_delay_set_taps();`` which will do an atomic update of all the -active delay lines tap positions at once. - -Delay taps ----------- - -The delays on the microphones are calculated in a spread sheet included at the root folder of the application, -``mic_array_das_beamformer_calcs.xls``. The beam is focused to a point of one meter away at an angle of -thirty degrees from the plane of the microphone array in the direction indicated by the LEDs. - -References ----------- - -.. nopoints:: - - * XMOS Tools User Guide - - http://www.xmos.com/published/xtimecomposer-user-guide - - * XMOS xCORE Programming Guide - - http://www.xmos.com/published/xmos-programming-guide - - * XMOS Microphone Array Library - - http://www.xmos.com/support/libraries/lib_mic_array - - * XMOS |I2C| Library - - http://www.xmos.com/support/libraries/lib_i2c - - * XMOS |I2S| Library - - http://www.xmos.com/support/libraries/lib_i2s - - -|newpage| - -Full source code listing ------------------------- - -Source code for app_hires_DAS_fixed.xc -...................................... - -.. literalinclude:: app_hires_DAS_fixed.xc - :largelisting: - -|newpage| diff --git a/examples/AN00218_app_hires_DAS_fixed/doc/rst/block_diagram.dot b/examples/AN00218_app_hires_DAS_fixed/doc/rst/block_diagram.dot deleted file mode 100644 index 32652cd2..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/doc/rst/block_diagram.dot +++ /dev/null @@ -1,29 +0,0 @@ -digraph g { - - i2s_master [label="i2s_master()", color=blue]; - i2c_master_single_port [label="i2c_master_single_port()", color=blue]; - i2s_handler [label="i2s_handler()", color=blue]; - button_and_led_server [label="button_and_led_server()", color=red]; - mic_array_pdm_rx [label="mic_array_pdm_rx()", color=red]; - mic_array_hires_delay [label="mic_array_hires_delay()", color=red]; - mic_array_decimate_to_pcm_4ch1 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - mic_array_decimate_to_pcm_4ch0 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - hires_DAS_fixed [label="hires_DAS_fixed()", color=red]; - - pdm_mic [label="PDM Microphone", shape=box]; - dac [label="Audio DAC", shape=box]; - - pdm_mic -> mic_array_pdm_rx; - - mic_array_pdm_rx -> mic_array_hires_delay; - mic_array_hires_delay -> mic_array_decimate_to_pcm_4ch0; - mic_array_hires_delay -> mic_array_decimate_to_pcm_4ch1; - - button_and_led_server -> hires_DAS_fixed; - mic_array_decimate_to_pcm_4ch0 -> hires_DAS_fixed; - mic_array_decimate_to_pcm_4ch1 -> hires_DAS_fixed; - hires_DAS_fixed -> i2s_handler; - i2s_handler -> i2s_master; - i2s_master -> dac; - i2c_master_single_port -> dac; -} \ No newline at end of file diff --git a/examples/AN00218_app_hires_DAS_fixed/doc/rst/block_diagram.pdf b/examples/AN00218_app_hires_DAS_fixed/doc/rst/block_diagram.pdf deleted file mode 100644 index 3ee77cbd..00000000 Binary files a/examples/AN00218_app_hires_DAS_fixed/doc/rst/block_diagram.pdf and /dev/null differ diff --git a/examples/AN00218_app_hires_DAS_fixed/doc/rst/setup.jpg b/examples/AN00218_app_hires_DAS_fixed/doc/rst/setup.jpg deleted file mode 100644 index 2a1f6085..00000000 Binary files a/examples/AN00218_app_hires_DAS_fixed/doc/rst/setup.jpg and /dev/null differ diff --git a/examples/AN00218_app_hires_DAS_fixed/doc/rst/xdoc.conf b/examples/AN00218_app_hires_DAS_fixed/doc/rst/xdoc.conf deleted file mode 100644 index 37460abf..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/doc/rst/xdoc.conf +++ /dev/null @@ -1,2 +0,0 @@ -XMOSNEWSTYLE=1 -SOURCE_INCLUDE_DIRS=../../src \ No newline at end of file diff --git a/examples/AN00218_app_hires_DAS_fixed/mic_array_das_beamformer_calcs.xls b/examples/AN00218_app_hires_DAS_fixed/mic_array_das_beamformer_calcs.xls deleted file mode 100644 index b6275fc1..00000000 Binary files a/examples/AN00218_app_hires_DAS_fixed/mic_array_das_beamformer_calcs.xls and /dev/null differ diff --git a/examples/AN00218_app_hires_DAS_fixed/src/app_hires_DAS_fixed.xc b/examples/AN00218_app_hires_DAS_fixed/src/app_hires_DAS_fixed.xc deleted file mode 100644 index c50f1c98..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/src/app_hires_DAS_fixed.xc +++ /dev/null @@ -1,277 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include - -#include "mic_array.h" -#include "mic_array_board_support.h" -#include "debug_print.h" - -#include "i2c.h" -#include "i2s.h" - -//If the decimation factor is changed the the coefs array of decimator_config must also be changed. -#define DECIMATION_FACTOR 2 //Corresponds to a 48kHz output sample rate -#define DECIMATOR_COUNT 2 //8 channels requires 2 decimators -#define FRAME_BUFFER_COUNT 2 //The minimum of 2 will suffice for this example - -on tile[0]:mabs_led_ports_t leds = MIC_BOARD_SUPPORT_LED_PORTS; -on tile[0]:in port p_buttons = MIC_BOARD_SUPPORT_BUTTON_PORTS; - -on tile[0]: out port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -out buffered port:32 p_i2s_dout[1] = on tile[1]: {XS1_PORT_1P}; -in port p_mclk_in1 = on tile[1]: XS1_PORT_1O; -out buffered port:32 p_bclk = on tile[1]: XS1_PORT_1M; -out buffered port:32 p_lrclk = on tile[1]: XS1_PORT_1N; -port p_i2c = on tile[1]: XS1_PORT_4E; // Bit 0: SCLK, Bit 1: SDA -port p_rst_shared = on tile[1]: XS1_PORT_4F; // Bit 0: DAC_RST_N, Bit 1: ETH_RST_N -clock mclk = on tile[1]: XS1_CLKBLK_3; -clock bclk = on tile[1]: XS1_CLKBLK_4; - -// Based on the spreadsheet mic_array_das_beamformer_calcs.xls, -// which can be found in the root directory of this app -static const one_meter_thirty_degrees[6] = {0, 23, 66, 87, 66, 23}; - -static void set_dir(client interface mabs_led_button_if lb, - unsigned dir, unsigned delay[]) { - - for(unsigned i=0;i>3; - debug_printf("gain: %d\n", gain); - break; - - case 2: - if (gain < 1) - gain = 1; - int new_gain = ((gain<<1) + gain)>>1; - if (new_gain - gain == 0) - new_gain++; - gain = new_gain; - debug_printf("gain: %d\n", gain); - break; - - case 3: - dir++; - if(dir == 6) - dir = 0; - set_dir(lb, dir, delay); - - debug_printf("dir %d\n", dir+1); - for(unsigned i=0;i<7;i++) - debug_printf("delay[%d] = %d\n", i, delay[i]); - debug_printf("\n"); - - mic_array_hires_delay_set_taps(c_cmd, delay, 7); - break; - } - } - break; - } - default:break; - } - int output = 0; - for(unsigned i=0;i<7;i++) - output += (current->data[i][0]>>3); - output = ((int64_t)output * (int64_t)gain)>>16; - - // Update the center LED with a volume indicator - unsigned value = output >> 20; - unsigned magnitude = (value * value) >> 8; - lb.set_led_brightness(12, magnitude); - - c_audio <: output; - c_audio <: output; - } - } -} - -#define MASTER_TO_PDM_CLOCK_DIVIDER 4 -#define MASTER_CLOCK_FREQUENCY 24576000 -#define PDM_CLOCK_FREQUENCY (MASTER_CLOCK_FREQUENCY/(2*MASTER_TO_PDM_CLOCK_DIVIDER)) -#define OUTPUT_SAMPLE_RATE (PDM_CLOCK_FREQUENCY/(32*DECIMATION_FACTOR)) - -[[distributable]] -void i2s_handler(server i2s_callback_if i2s, - client i2c_master_if i2c, chanend c_audio) { - p_rst_shared <: 0xF; - - mabs_init_pll(i2c, ETH_MIC_ARRAY); - - i2c_regop_res_t res; - int i = 0x4A; - - uint8_t data = 1; - res = i2c.write_reg(i, 0x02, data); // Power down - - data = 0x08; - res = i2c.write_reg(i, 0x04, data); // Slave, I2S mode, up to 24-bit - - data = 0; - res = i2c.write_reg(i, 0x03, data); // Disable Auto mode and MCLKDIV2 - - data = 0x00; - res = i2c.write_reg(i, 0x09, data); // Disable DSP - - data = 0; - res = i2c.write_reg(i, 0x02, data); // Power up - - while (1) { - select { - case i2s.init(i2s_config_t &?i2s_config, tdm_config_t &?tdm_config): - i2s_config.mode = I2S_MODE_I2S; - i2s_config.mclk_bclk_ratio = (MASTER_CLOCK_FREQUENCY/OUTPUT_SAMPLE_RATE)/64; - break; - - case i2s.restart_check() -> i2s_restart_t restart: - restart = I2S_NO_RESTART; - break; - - case i2s.receive(size_t index, int32_t sample): - break; - - case i2s.send(size_t index) -> int32_t sample: - c_audio:> sample; - break; - } - } -} - -int main() { - - i2s_callback_if i_i2s; - i2c_master_if i_i2c[1]; - chan c_audio; - par { - on tile[1]: { - configure_clock_src(mclk, p_mclk_in1); - start_clock(mclk); - i2s_master(i_i2s, p_i2s_dout, 1, null, 0, p_bclk, p_lrclk, bclk, mclk); - } - - on tile[1]: [[distribute]]i2c_master_single_port(i_i2c, 1, p_i2c, 100, 0, 1, 0); - on tile[1]: [[distribute]]i2s_handler(i_i2s, i_i2c[0], c_audio); - - on tile[0]: { - configure_clock_src_divide(pdmclk, p_mclk, MASTER_TO_PDM_CLOCK_DIVIDER); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - streaming chan c_pdm_to_hires[2]; - streaming chan c_hires_to_dec[2]; - streaming chan c_ds_output[2]; - streaming chan c_cmd; - - interface mabs_led_button_if lb[1]; - - par { - mabs_button_and_led_server(lb, 1, leds, p_buttons); - - mic_array_pdm_rx(p_pdm_mics, c_pdm_to_hires[0], c_pdm_to_hires[1]); - mic_array_hires_delay(c_pdm_to_hires, c_hires_to_dec, 2, c_cmd); - mic_array_decimate_to_pcm_4ch(c_hires_to_dec[0], c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_hires_to_dec[1], c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - hires_DAS_fixed(c_ds_output, c_cmd, lb[0], c_audio); - } - stop_clock(pdmclk); - } - } - - return 0; -} diff --git a/examples/AN00218_app_hires_DAS_fixed/src/mic_array_conf.h b/examples/AN00218_app_hires_DAS_fixed/src/mic_array_conf.h deleted file mode 100644 index 6ed389be..00000000 --- a/examples/AN00218_app_hires_DAS_fixed/src/mic_array_conf.h +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 8 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/examples/AN00219_app_lores_DAS_fixed/.cproject b/examples/AN00219_app_lores_DAS_fixed/.cproject deleted file mode 100644 index 6fc3f49e..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/.cproject +++ /dev/null @@ -1,1033 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00219_app_lores_DAS_fixed/.project b/examples/AN00219_app_lores_DAS_fixed/.project deleted file mode 100644 index f97bcb66..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - AN00219_app_lores_DAS_fixed - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/examples/AN00219_app_lores_DAS_fixed/LICENSE.rst b/examples/AN00219_app_lores_DAS_fixed/LICENSE.rst deleted file mode 100644 index ca48f20f..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/LICENSE.rst +++ /dev/null @@ -1,84 +0,0 @@ -******************************* -XMOS PUBLIC LICENCE: Version 1 -******************************* - -Subject to the conditions and limitations below, permission is hereby granted by XMOS LIMITED (“XMOS”), free of charge, to any person or entity obtaining a copy of the XMOS Software. - -**1. Definitions** - -**“Applicable Patent Rights”** means: (a) where XMOS is the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to XMOS and (ii) that cover subject matter contained in the Software, but only to the extent it is necessary to use, reproduce or distribute the Software without infringement; and (b) where you are the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to you and (ii) that cover the subject matter contained in your Derivatives, taken alone or in combination with the Software. - -**“Compiled Code”** means any compiled, binary, machine readable or executable version of the Source Code. - -**“Contributor”** means any person or entity that creates or contributes to the creation of Derivatives. - -**“Derivatives”** means any addition to, deletion from and/or change to the substance, structure of the Software, any previous Derivatives, the combination of the Derivatives and the Software and/or any respective portions thereof. - -**“Source Code”** means the human readable code that is suitable for making modifications but excluding any Compiled Code. - -**“Software”** means the software and associated documentation files which XMOS makes available and which contain a notice identifying the software as original XMOS software and referring to the software being subject to the terms of this XMOS Public Licence. - -This Licence refers to XMOS Software and does not relate to any XMOS hardware or devices which are protected by intellectual property rights (including patent and trade marks) which may be sold to you under a separate agreement. - - -**2. Licence** - -**Permitted Uses, Conditions and Restrictions.** Subject to the conditions below, XMOS grants you a worldwide, royalty free, non-exclusive licence, to the extent of any Patent Rights to do the following: - -2.1 **Unmodified Software.** You may use, copy, display, publish, distribute and make available unmodified copies of the Software: - -2.1.1 for personal or academic, non-commercial purposes; or - -2.1.2 for commercial purposes provided the Software is at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.1.1 and 2.1.2): - -(a) you must retain and reproduce in all copies of the Software the copyright and proprietary notices and disclaimers of XMOS as they appear in the Software, and keep intact all notices and disclaimers in the Software files that refer to this Licence; and - -(b) you must include a copy of this Licence with every copy of the Software and documentation you publish, distribute and make available and you may not offer or impose any terms on such Software that alter or restrict this Licence or the intent of such Licence, except as permitted below (Additional Terms). - -The licence above does not include any Compiled Code which XMOS may make available under a separate support and licence agreement. - -2.2 **Derivatives.** You may create and modify Derivatives and use, copy, display, publish, distribute and make available Derivatives: - -2.2.1 for personal or academic, non-commercial purposes; or - -2.2.2 for commercial purposes, provided the Derivatives are at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.2.1 and 2.2.2): - -(a) you must comply with the terms of clause 2.1 with respect to the Derivatives; - -(b) you must copy (to the extent it doesn’t already exist) the notice below in each file of the Derivatives, and ensure all the modified files carry prominent notices stating that you have changed the files and the date of any change; and - -(c) if you sublicence, distribute or otherwise make the Software and/or the Derivatives available for commercial purposes, you must provide that the Software and Derivatives are at all times used on a device designed, licensed or developed by XMOS. - -Without limitation to these terms and clause 3 below, the Source Code and Compiled Code to your Derivatives may at your discretion (but without obligation) be released, copied, displayed, published, distributed and made available; and if you elect to do so, it must be under the terms of this Licence including the terms of the licence at clauses 2.2.1, 2.2.2 and clause 3 below. - -2.3 **Distribution of Executable Versions.** If you distribute or make available Derivatives, you must include a prominent notice in the code itself as well as in all related documentation, stating that the Source Code of the Software from which the Derivatives are based is available under the terms of this Licence, with information on how and where to obtain such Source Code. - -**3. Your Grant of Rights.** In consideration and as a condition to this Licence, you grant to any person or entity receiving or distributing any Derivatives, a non-exclusive, royalty free, perpetual, irrevocable license under your Applicable Patent Rights and all other intellectual property rights owned or controlled by you, to use, copy, display, publish, distribute and make available your Derivatives of the same scope and extent as XMOS’s licence under clause 2.2 above. - -**4. Combined Products.** You may create a combined product by combining Software, Derivatives and other code not covered by this Licence as a single application or product. In such instance, you must comply with the requirements of this Licence for any portion of the Software and/or Derivatives. - -**5. Additional Terms.** You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the term of this Licence (“Additional Terms”) to any legitimate recipients of the Software and/or Derivatives. The terms on which you provide such Additional Terms are on your sole responsibility and you shall indemnify, defend and hold XMOS harmless against any claims asserted against XMOS. - -**6. New Versions.** XMOS may publish revised and/or new versions of this Licence from time to time to accommodate changes to the Licence terms, new versions, updates and bug fixes of the Software. Each version will be given a distinguishing version number. Once Software has been published under a particular version of this Licence, you may continue to use it under the terms of that version. You may also choose to use the latest version of the Software under any subsequent version published by XMOS. Only XMOS shall have the right to modify these terms. - -**7. IPR and Ownership** -Any rights, including all intellectual property rights and all trademarks not expressly granted herein are reserved in full by the authors or copyright holders. Any requests for additional permissions by XMOS including any rights to use XMOS trademarks, should be made (without obligation) to XMOS at **support@xmos.com** - -Nothing herein shall limit any rights that XMOS is otherwise entitled to under the doctrines of patent exhaustion, implied license, or legal estoppel. Neither the name of the authors, the copyright holders or any contributors may be used to endorse or promote any Derivatives from this Software without specific written permission. Any attempt to deal with the Software which does not comply with this Licence shall be void and shall automatically terminate any rights granted under this licence (including any licence of any intellectual property rights granted herein). -Subject to the licences granted under this Licence any Contributor retains all rights, title and interest in and to any Derivatives made by Contributor subject to the underlying rights of XMOS in the Software. XMOS shall retain all rights, title and interest in the Software and any Derivatives made by XMOS (“XMOS Derivatives”). XMOS Derivatives will not automatically be subject to this Licence and XMOS shall be entitled to licence such rights on any terms (without obligation) as it sees fit. - -**8. Termination** - -8.1 This Licence will automatically terminate immediately, without notice to you, if: - -(a) you fail to comply with the terms of this Licence; and/or - -(b) you directly or indirectly commence any action for patent or intellectual property right infringement against XMOS, or any parent, group, affiliate or subsidiary of XMOS; provided XMOS did not first commence an action or patent infringement against you in that instance; and/or - -(c) the terms of this Licence are held by any court of competent jurisdiction to be unenforceable in whole or in part. - -**9. Critical Applications.** Unless XMOS has agreed in writing with you an agreement specifically governing use of the Goods in military, aerospace, automotive or medically related functions (collectively and individually hereinafter referred to as "Special Use"), any permitted use of the Software excludes Special Use. Notwithstanding any agreement between XMOS and you for Special Use, Special Use shall be at your own risk, and you shall fully indemnify XMOS against any damages, losses, costs and claims (direct and indirect) arising out of any Special Use. - -**10. NO WARRANTY OR SUPPORT.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL XMOS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, WARRANTY, CIVIL TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE INCLUDING GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES EVEN IF SUCH PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOT WITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE. IN SOME JURISDICTIONS PARTIES ARE UNABLE TO LIMIT LIABILTY IN THIS WAY, IF THIS APPLIES TO YOUR JURISDICTION THIS LIABILITY CLAUSE ABOVE MAY NOT APPLY. NOTWITHSTANDING THE ABOVE, IN NO EVENT SHALL XMOS’s TOTAL LIABILITY TO YOU FOR ALL DAMAGES, LOSS OR OTHERWISE EXCEED $50. - -**11. Governing Law and Jurisdiction.** This Licence constitutes the entire agreement between the parties with respect to the subject matter hereof. The Licence shall be governed by the laws of England and the conflict of laws and UN Convention on Contracts for the International Sale of Goods, shall not apply. diff --git a/examples/AN00219_app_lores_DAS_fixed/MIC-ARRAY-1V0.xn b/examples/AN00219_app_lores_DAS_fixed/MIC-ARRAY-1V0.xn deleted file mode 100644 index e8efb894..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/MIC-ARRAY-1V0.xn +++ /dev/null @@ -1,115 +0,0 @@ - - - Board - XS2 MC Audio - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00219_app_lores_DAS_fixed/Makefile b/examples/AN00219_app_lores_DAS_fixed/Makefile deleted file mode 100644 index c9b09b9d..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = MIC-ARRAY-1V0 - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = app_lores_DAS_fixed - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_i2c(>=4.0.0) lib_i2s(>=2.2.0) lib_mic_array(>=3.0.0) lib_mic_array_board_support(>=2.1.0) - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g -DDEBUG_PRINT_ENABLE=1 - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/examples/AN00219_app_lores_DAS_fixed/README.rst b/examples/AN00219_app_lores_DAS_fixed/README.rst deleted file mode 100644 index da9b196c..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/README.rst +++ /dev/null @@ -1,36 +0,0 @@ -.. |I2S| replace:: I\ :sup:`2`\ S -.. |I2C| replace:: I\ :sup:`2`\ C - -Low Resolution Delay and Sum -============================ - -Summary -------- - -Software dependencies -..................... - -For a list of direct dependencies, look for USED_MODULES in the Makefile. - -Required hardware -................. - -The example code provided with the application has been implemented -and tested on the Microphone Array Ref Design v1. - -Prerequisites -............. - - * This document assumes familiarity with the XMOS xCORE architecture, - the XMOS tool chain and the xC language. Documentation related to these - aspects which are not specific to this application note are linked to in - the references appendix. - - * The ``lib_mic_array`` user guide should be thoroughly read and understood. - - * For a description of XMOS related terms found in this document - please see the XMOS Glossary [#]_. - -.. [#] http://www.xmos.com/published/glossary - - diff --git a/examples/AN00219_app_lores_DAS_fixed/config.xscope b/examples/AN00219_app_lores_DAS_fixed/config.xscope deleted file mode 100644 index 125b9c29..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00219_app_lores_DAS_fixed/doc/rst/AN00219.rst b/examples/AN00219_app_lores_DAS_fixed/doc/rst/AN00219.rst deleted file mode 100644 index 7f68e227..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/doc/rst/AN00219.rst +++ /dev/null @@ -1,269 +0,0 @@ -.. include:: ../../README.rst - -|newpage| - -Overview --------- - -Introduction -............ - -This demo application shows a simple Delay and Sum (DAS) bemformer. -It shows the setup of the |I2S| for audio output via the DAC and very simple processing of -multi-channel audio frames to produce a single channel output based on a simple single steering direction. - -Block diagram -............. - -.. figure:: block_diagram.pdf - :width: 80% - - Application block diagram - -How to use lib_mic_array ------------------------- - -The Makefile -............ - -To start using the microphone array library, you need to add ``lib_mic_array`` to you Makefile:: - - USED_MODULES = .. lib_mic_array ... - -This demo also uses the logging library (``lib_logging``) for the ``debug_printf`` -function. This is a faster, but more limited version of the C-Standard Library -``printf`` function. So the Makefile also includes:: - - USED_MODULES = .. lib_logging .. - -The logging library is configurable at compile-time allowing calls to -``debug_printf()`` to be easily enabled or disabled. For the prints to -be enabled it is necessary to add the following to the compile flags:: - - XCC_FLAGS = .. -DDEBUG_PRINT_ENABLE=1 .. - -Includes -........ - -This application requires the system headers that defines XMOS xCORE specific -defines for declaring and initialising hardware: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: include - :end-on: include - -The microphone array library functions are defined in ``lib_mic_array.h``. This header must -be included in your code to use the library. The support functions for the board are defined in -``mic_array_board_support.h`` and the logging functions are provided by ``debug_print.h``. - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: include "mic_array.h" - :end-on: include "debug_print.h" - -Also required is support for |I2S| and |I2C| through the headers: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: include "i2c.h" - :end-on: include "i2s.h" - -Allocating hardware resources -............................. - -A PDM microphone requires a clock and a data pin. For eight PDM microphones a single -clock can be shared between all microphones and the data can be sampled on a single -8 bit port. On an xCORE the pins are controlled by ``ports``. The application therefore -declares one 1-bit port and one 8-bit port: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: in port p_pdm_clk - :end-on: in buffered port:32 p_pdm_mics - -To generate the PDM clock a 24.576MHz master clock is divided by 8 using a clock block. These two hardware -resources are declared with: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: in port p_mclk - :end-on: clock pdmclk - -and are configured with: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: configure_clock_src_divide(pdmclk - :end-on: start_clock(pdmclk); - -The result begin a 3.072MHz PDM clock is used for clocking the microphone data into the xCORE. Additionally, -the LEDs and buttons are declared by - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: p_leds leds - :end-on: in port p_buttons - -And the |I2S| is declared with: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: p_i2s_dout[1] - :end-on: clock bclk - -Demo Hardware Setup -------------------- - -To run the demo, connect a USB cable to power the Microphone Array Ref Design v1 -and plug the xTAG to the board and connect the xTAG USB cable to your -development machine. You will also need to connect headphones to the audio jack. - -.. figure:: setup.jpg - :width: 80% - - Hardware setup - -|newpage| - -Launching the demo application ------------------------------- - -Once the demo example has been built either from the command line using xmake or -via the build mechanism of xTIMEcomposer studio it can be executed on the Microphone Array Ref Design v1. - -Once built there will be a ``bin/`` directory within the project which contains -the binary for the xCORE device. The xCORE binary has a XMOS standard .xe extension. - -Launching from the command line -............................... - -From the command line you use the ``xrun`` tool to download and run the code -on the xCORE device:: - - xrun --xscope bin/app_lores_DAS_fixed.xe - -Once this command has executed the application will be running on the -Microphone Array Ref Design v1. - -Launching from xTIMEcomposer Studio -................................... - -From xTIMEcomposer Studio use the run mechanism to download code to xCORE device. -Select the xCORE binary from the ``bin/`` directory, right click and go to Run -Configurations. Double click on xCORE application to create a new run configuration, -enable the xSCOPE I/O mode in the dialog box and then -select Run. - -Once this command has executed the application will be running on the -Microphone Array Ref Design v1. - -Running the application -....................... - -Once the application is started using either of the above methods there will -be the output of the microphones through the headphones. - -Buttons ``A`` and ``D`` rotate the direction of the beam which is indicated by the LEDs. -Buttons ``B`` and ``C`` decrease and increase the gain on the output signal respectively. - -|newpage| - -Task setup ----------- - -The PDM microphones interface task and the decimators have to be connected -together and to the application (``lores_DAS_fixed()``). There needs to be one -``mic_array_decimate_to_pcm_4ch()`` task per four channels that need processing. -The PDM interface task, ``mic_array_pdm_rx()`` can process eight channels so only -one is needed for this application. The PDM interface needs to be connected to the -decimators via two streaming channels. Finally, the decimators have to be connected to -the application. - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: streaming chan c_4x_pdm_mic[ - :end-before: return 0 - -Note that the decimators have to be on the same tile as the application due to shared frame memory. - -Frame memory ------------- - -For each decimator an block of memory must be allocated for storing FIR data. The size of the data -block must be:: - - Number of channels for that decimator * THIRD_STAGE_COEFS_PER_STAGE * Decimation factor * sizeof(int) - -bytes. The data must also be double word aligned. For example: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: int data[8] - :end-before: void lores_DAS_fixed - -Note that on the xCORE-200 all global arrays are guaranteed to be double-word aligned. - -Configuration -------------- - -Configuration of the microphone array for the example is achieved through: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: mic_array_decimator_conf_common_t dcc = - :end-before: mic_array_init_time_domain_frame - -All configuration options are described in the Microphone array library guide. Once configured -then the decimators require initialization via: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: mic_array_init_time_domain_frame - :end-before: while(1) - -The decimators will start presenting samples in the form of frames that can be accessed with: - -.. literalinclude:: app_lores_DAS_fixed.xc - :start-on: mic_array_frame_time_domain * current = - :end-on: mic_array_get_next_time_domain_frame - -The return value of ``mic_array_get_next_time_domain_frame()`` is a pointer to the frame that -the application is allowed to access. The ``current`` frame contains the frame data in the -``data`` member. ``data`` is a 2D array with the first index denoting the channel number and -the second index denoting the frame index. The frame index used 0 for the oldest samples and -increasing indices for newer samples. - -Delay taps ----------- - -The delays on the microphones are calculated in a spread sheet included at the root folder of the application, -``mic_array_das_beamformer_calcs.xls``. The beam is focused to a point of one meter away at an angle of -thirty degrees from the plane of the microphone array in the direction indicated by the LEDs. - -References ----------- - -.. nopoints:: - - * XMOS Tools User Guide - - http://www.xmos.com/published/xtimecomposer-user-guide - - * XMOS xCORE Programming Guide - - http://www.xmos.com/published/xmos-programming-guide - - * XMOS Microphone Array Library - - http://www.xmos.com/support/libraries/lib_mic_array - - * XMOS |I2C| Library - - http://www.xmos.com/support/libraries/lib_i2c - - * XMOS |I2S| Library - - http://www.xmos.com/support/libraries/lib_i2s - - -|newpage| - -Full source code listing ------------------------- - -Source code for app_lores_DAS_fixed.xc -...................................... - -.. literalinclude:: app_lores_DAS_fixed.xc - :largelisting: - -|newpage| diff --git a/examples/AN00219_app_lores_DAS_fixed/doc/rst/block_diagram.dot b/examples/AN00219_app_lores_DAS_fixed/doc/rst/block_diagram.dot deleted file mode 100644 index 6201741b..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/doc/rst/block_diagram.dot +++ /dev/null @@ -1,27 +0,0 @@ -digraph g { - - i2s_master [label="i2s_master()", color=blue]; - i2c_master_single_port [label="i2c_master_single_port()", color=blue]; - i2s_handler [label="i2s_handler()", color=blue]; - button_and_led_server [label="button_and_led_server()", color=red]; - mic_array_pdm_rx [label="mic_array_pdm_rx()", color=red]; - mic_array_decimate_to_pcm_4ch1 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - mic_array_decimate_to_pcm_4ch0 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - hires_DAS_fixed [label="hires_DAS_fixed()", color=red]; - - pdm_mic [label="PDM Microphone", shape=box]; - dac [label="Audio DAC", shape=box]; - - pdm_mic -> mic_array_pdm_rx; - - mic_array_pdm_rx -> mic_array_decimate_to_pcm_4ch0; - mic_array_pdm_rx -> mic_array_decimate_to_pcm_4ch1; - - button_and_led_server -> hires_DAS_fixed; - mic_array_decimate_to_pcm_4ch0 -> hires_DAS_fixed; - mic_array_decimate_to_pcm_4ch1 -> hires_DAS_fixed; - hires_DAS_fixed -> i2s_handler; - i2s_handler -> i2s_master; - i2s_master -> dac; - i2c_master_single_port -> dac; -} \ No newline at end of file diff --git a/examples/AN00219_app_lores_DAS_fixed/doc/rst/block_diagram.pdf b/examples/AN00219_app_lores_DAS_fixed/doc/rst/block_diagram.pdf deleted file mode 100644 index f1ac1459..00000000 Binary files a/examples/AN00219_app_lores_DAS_fixed/doc/rst/block_diagram.pdf and /dev/null differ diff --git a/examples/AN00219_app_lores_DAS_fixed/doc/rst/setup.jpg b/examples/AN00219_app_lores_DAS_fixed/doc/rst/setup.jpg deleted file mode 100644 index 2a1f6085..00000000 Binary files a/examples/AN00219_app_lores_DAS_fixed/doc/rst/setup.jpg and /dev/null differ diff --git a/examples/AN00219_app_lores_DAS_fixed/doc/rst/xdoc.conf b/examples/AN00219_app_lores_DAS_fixed/doc/rst/xdoc.conf deleted file mode 100644 index 37460abf..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/doc/rst/xdoc.conf +++ /dev/null @@ -1,2 +0,0 @@ -XMOSNEWSTYLE=1 -SOURCE_INCLUDE_DIRS=../../src \ No newline at end of file diff --git a/examples/AN00219_app_lores_DAS_fixed/mic_array_das_beamformer_calcs.xls b/examples/AN00219_app_lores_DAS_fixed/mic_array_das_beamformer_calcs.xls deleted file mode 100644 index 7de4eed6..00000000 Binary files a/examples/AN00219_app_lores_DAS_fixed/mic_array_das_beamformer_calcs.xls and /dev/null differ diff --git a/examples/AN00219_app_lores_DAS_fixed/src/app_lores_DAS_fixed.xc b/examples/AN00219_app_lores_DAS_fixed/src/app_lores_DAS_fixed.xc deleted file mode 100644 index 25a0185d..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/src/app_lores_DAS_fixed.xc +++ /dev/null @@ -1,284 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include - -#include "mic_array.h" -#include "mic_array_board_support.h" -#include "debug_print.h" - -#include "i2c.h" -#include "i2s.h" - -//If the decimation factor is changed the the coefs array of decimator_config must also be changed. -#define DECIMATION_FACTOR 2 //Corresponds to a 48kHz output sample rate -#define DECIMATOR_COUNT 2 //8 channels requires 2 decimators -#define FRAME_BUFFER_COUNT 2 //The minimum of 2 will suffice for this example - -on tile[0]:mabs_led_ports_t leds = MIC_BOARD_SUPPORT_LED_PORTS; -on tile[0]:in port p_buttons = MIC_BOARD_SUPPORT_BUTTON_PORTS; - -on tile[0]: out port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -out buffered port:32 p_i2s_dout[1] = on tile[1]: {XS1_PORT_1P}; -in port p_mclk_in1 = on tile[1]: XS1_PORT_1O; -out buffered port:32 p_bclk = on tile[1]: XS1_PORT_1M; -out buffered port:32 p_lrclk = on tile[1]: XS1_PORT_1N; -port p_i2c = on tile[1]: XS1_PORT_4E; // Bit 0: SCLK, Bit 1: SDA -port p_rst_shared = on tile[1]: XS1_PORT_4F; // Bit 0: DAC_RST_N, Bit 1: ETH_RST_N -clock mclk = on tile[1]: XS1_CLKBLK_3; -clock bclk = on tile[1]: XS1_CLKBLK_4; - -// Based on the spreadsheet mic_array_das_beamformer_calcs.xls, -// which can be found in the root directory of this app -static const one_meter_thirty_degrees[6] = {0, 3, 8, 11, 8, 3}; - -static void set_dir(client interface mabs_led_button_if lb, - unsigned dir, unsigned delay[]) { - - for(unsigned i=0;idata[i][0]; - - // light the LED for the current direction - int t; - select { - case lb.button_event():{ - unsigned button; - mabs_button_state_t pressed; - lb.get_button_event(button, pressed); - if(pressed == BUTTON_PRESSED){ - switch(button){ - case 0: - dir--; - if(dir == -1) - dir = 5; - set_dir(lb, dir, delay); - debug_printf("dir %d\n", dir+1); - for(unsigned i=0;i<7;i++) - debug_printf("delay[%d] = %d\n", i, delay[i]); - debug_printf("\n"); - break; - - case 1: - gain = ((gain<<3) - gain)>>3; - debug_printf("gain: %d\n", gain); - break; - - case 2: - if (gain < 1) - gain = 1; - int new_gain = ((gain<<1) + gain)>>1; - if (new_gain - gain == 0) - new_gain++; - gain = new_gain; - debug_printf("gain: %d\n", gain); - break; - - case 3: - dir++; - if(dir == 6) - dir = 0; - set_dir(lb, dir, delay); - debug_printf("dir %d\n", dir+1); - for(unsigned i=0;i<7;i++) - debug_printf("delay[%d] = %d\n", i, delay[i]); - debug_printf("\n"); - break; - } - } - break; - } - default:break; - } - int output = 0; - for(unsigned i=0;i<7;i++) - output += (delay_buffer[(delay_head - delay[i])%MAX_DELAY][i]>>3); - - output = ((int64_t)output * (int64_t)gain)>>16; - - - // Update the center LED with a volume indicator - unsigned value = output >> 20; - unsigned magnitude = (value * value) >> 8; - lb.set_led_brightness(12, magnitude); - - c_audio <: output; - c_audio <: output; - delay_head++; - delay_head%=MAX_DELAY; - } - } -} - -#define MASTER_TO_PDM_CLOCK_DIVIDER 4 -#define MASTER_CLOCK_FREQUENCY 24576000 -#define PDM_CLOCK_FREQUENCY (MASTER_CLOCK_FREQUENCY/(2*MASTER_TO_PDM_CLOCK_DIVIDER)) -#define OUTPUT_SAMPLE_RATE (PDM_CLOCK_FREQUENCY/(32*DECIMATION_FACTOR)) - -[[distributable]] -void i2s_handler(server i2s_callback_if i2s, - client i2c_master_if i2c, chanend c_audio) { - p_rst_shared <: 0xF; - - mabs_init_pll(i2c, ETH_MIC_ARRAY); - - i2c_regop_res_t res; - int i = 0x4A; - - uint8_t data = 1; - res = i2c.write_reg(i, 0x02, data); // Power down - - data = 0x08; - res = i2c.write_reg(i, 0x04, data); // Slave, I2S mode, up to 24-bit - - data = 0; - res = i2c.write_reg(i, 0x03, data); // Disable Auto mode and MCLKDIV2 - - data = 0x00; - res = i2c.write_reg(i, 0x09, data); // Disable DSP - - data = 0; - res = i2c.write_reg(i, 0x02, data); // Power up - -#define CS2100_I2C_DEVICE_ADDR (0x9c>>1) - res = i2c.write_reg(CS2100_I2C_DEVICE_ADDR, 0x3, 0); // Reset the PLL to use the aux out - - - while (1) { - select { - case i2s.init(i2s_config_t &?i2s_config, tdm_config_t &?tdm_config): - i2s_config.mode = I2S_MODE_I2S; - i2s_config.mclk_bclk_ratio = (MASTER_CLOCK_FREQUENCY/OUTPUT_SAMPLE_RATE)/64; - break; - - case i2s.restart_check() -> i2s_restart_t restart: - restart = I2S_NO_RESTART; - break; - - case i2s.receive(size_t index, int32_t sample): - break; - - case i2s.send(size_t index) -> int32_t sample: - c_audio:> sample; - break; - } - } -} - -int main() { - - i2s_callback_if i_i2s; - i2c_master_if i_i2c[1]; - chan c_audio; - par{ - - on tile[1]: { - configure_clock_src(mclk, p_mclk_in1); - start_clock(mclk); - i2s_master(i_i2s, p_i2s_dout, 1, null, 0, p_bclk, p_lrclk, bclk, mclk); - } - - on tile[1]: [[distribute]]i2c_master_single_port(i_i2c, 1, p_i2c, 100, 0, 1, 0); - on tile[1]: [[distribute]]i2s_handler(i_i2s, i_i2c[0], c_audio); - - on tile[0]: { - configure_clock_src_divide(pdmclk, p_mclk, MASTER_TO_PDM_CLOCK_DIVIDER); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - streaming chan c_4x_pdm_mic[DECIMATOR_COUNT]; - streaming chan c_ds_output[DECIMATOR_COUNT]; - - interface mabs_led_button_if lb[1]; - - par { - mabs_button_and_led_server(lb, 1, leds, p_buttons); - mic_array_pdm_rx(p_pdm_mics, c_4x_pdm_mic[0], c_4x_pdm_mic[1]); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic[0], c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic[1], c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - lores_DAS_fixed(c_ds_output, lb[0], c_audio); - par(int i=0;i<3;i++)while(1); - } - } - } - return 0; -} diff --git a/examples/AN00219_app_lores_DAS_fixed/src/mic_array_conf.h b/examples/AN00219_app_lores_DAS_fixed/src/mic_array_conf.h deleted file mode 100644 index f95dfdfe..00000000 --- a/examples/AN00219_app_lores_DAS_fixed/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 8 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/examples/AN00220_app_phase_aligned_example/.cproject b/examples/AN00220_app_phase_aligned_example/.cproject deleted file mode 100644 index aa0654dd..00000000 --- a/examples/AN00220_app_phase_aligned_example/.cproject +++ /dev/null @@ -1,956 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/examples/AN00220_app_phase_aligned_example/.project b/examples/AN00220_app_phase_aligned_example/.project deleted file mode 100644 index bf7f87f9..00000000 --- a/examples/AN00220_app_phase_aligned_example/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - AN00220_app_phase_aligned_example - - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/examples/AN00220_app_phase_aligned_example/LICENSE.rst b/examples/AN00220_app_phase_aligned_example/LICENSE.rst deleted file mode 100644 index ca48f20f..00000000 --- a/examples/AN00220_app_phase_aligned_example/LICENSE.rst +++ /dev/null @@ -1,84 +0,0 @@ -******************************* -XMOS PUBLIC LICENCE: Version 1 -******************************* - -Subject to the conditions and limitations below, permission is hereby granted by XMOS LIMITED (“XMOS”), free of charge, to any person or entity obtaining a copy of the XMOS Software. - -**1. Definitions** - -**“Applicable Patent Rights”** means: (a) where XMOS is the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to XMOS and (ii) that cover subject matter contained in the Software, but only to the extent it is necessary to use, reproduce or distribute the Software without infringement; and (b) where you are the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to you and (ii) that cover the subject matter contained in your Derivatives, taken alone or in combination with the Software. - -**“Compiled Code”** means any compiled, binary, machine readable or executable version of the Source Code. - -**“Contributor”** means any person or entity that creates or contributes to the creation of Derivatives. - -**“Derivatives”** means any addition to, deletion from and/or change to the substance, structure of the Software, any previous Derivatives, the combination of the Derivatives and the Software and/or any respective portions thereof. - -**“Source Code”** means the human readable code that is suitable for making modifications but excluding any Compiled Code. - -**“Software”** means the software and associated documentation files which XMOS makes available and which contain a notice identifying the software as original XMOS software and referring to the software being subject to the terms of this XMOS Public Licence. - -This Licence refers to XMOS Software and does not relate to any XMOS hardware or devices which are protected by intellectual property rights (including patent and trade marks) which may be sold to you under a separate agreement. - - -**2. Licence** - -**Permitted Uses, Conditions and Restrictions.** Subject to the conditions below, XMOS grants you a worldwide, royalty free, non-exclusive licence, to the extent of any Patent Rights to do the following: - -2.1 **Unmodified Software.** You may use, copy, display, publish, distribute and make available unmodified copies of the Software: - -2.1.1 for personal or academic, non-commercial purposes; or - -2.1.2 for commercial purposes provided the Software is at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.1.1 and 2.1.2): - -(a) you must retain and reproduce in all copies of the Software the copyright and proprietary notices and disclaimers of XMOS as they appear in the Software, and keep intact all notices and disclaimers in the Software files that refer to this Licence; and - -(b) you must include a copy of this Licence with every copy of the Software and documentation you publish, distribute and make available and you may not offer or impose any terms on such Software that alter or restrict this Licence or the intent of such Licence, except as permitted below (Additional Terms). - -The licence above does not include any Compiled Code which XMOS may make available under a separate support and licence agreement. - -2.2 **Derivatives.** You may create and modify Derivatives and use, copy, display, publish, distribute and make available Derivatives: - -2.2.1 for personal or academic, non-commercial purposes; or - -2.2.2 for commercial purposes, provided the Derivatives are at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.2.1 and 2.2.2): - -(a) you must comply with the terms of clause 2.1 with respect to the Derivatives; - -(b) you must copy (to the extent it doesn’t already exist) the notice below in each file of the Derivatives, and ensure all the modified files carry prominent notices stating that you have changed the files and the date of any change; and - -(c) if you sublicence, distribute or otherwise make the Software and/or the Derivatives available for commercial purposes, you must provide that the Software and Derivatives are at all times used on a device designed, licensed or developed by XMOS. - -Without limitation to these terms and clause 3 below, the Source Code and Compiled Code to your Derivatives may at your discretion (but without obligation) be released, copied, displayed, published, distributed and made available; and if you elect to do so, it must be under the terms of this Licence including the terms of the licence at clauses 2.2.1, 2.2.2 and clause 3 below. - -2.3 **Distribution of Executable Versions.** If you distribute or make available Derivatives, you must include a prominent notice in the code itself as well as in all related documentation, stating that the Source Code of the Software from which the Derivatives are based is available under the terms of this Licence, with information on how and where to obtain such Source Code. - -**3. Your Grant of Rights.** In consideration and as a condition to this Licence, you grant to any person or entity receiving or distributing any Derivatives, a non-exclusive, royalty free, perpetual, irrevocable license under your Applicable Patent Rights and all other intellectual property rights owned or controlled by you, to use, copy, display, publish, distribute and make available your Derivatives of the same scope and extent as XMOS’s licence under clause 2.2 above. - -**4. Combined Products.** You may create a combined product by combining Software, Derivatives and other code not covered by this Licence as a single application or product. In such instance, you must comply with the requirements of this Licence for any portion of the Software and/or Derivatives. - -**5. Additional Terms.** You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the term of this Licence (“Additional Terms”) to any legitimate recipients of the Software and/or Derivatives. The terms on which you provide such Additional Terms are on your sole responsibility and you shall indemnify, defend and hold XMOS harmless against any claims asserted against XMOS. - -**6. New Versions.** XMOS may publish revised and/or new versions of this Licence from time to time to accommodate changes to the Licence terms, new versions, updates and bug fixes of the Software. Each version will be given a distinguishing version number. Once Software has been published under a particular version of this Licence, you may continue to use it under the terms of that version. You may also choose to use the latest version of the Software under any subsequent version published by XMOS. Only XMOS shall have the right to modify these terms. - -**7. IPR and Ownership** -Any rights, including all intellectual property rights and all trademarks not expressly granted herein are reserved in full by the authors or copyright holders. Any requests for additional permissions by XMOS including any rights to use XMOS trademarks, should be made (without obligation) to XMOS at **support@xmos.com** - -Nothing herein shall limit any rights that XMOS is otherwise entitled to under the doctrines of patent exhaustion, implied license, or legal estoppel. Neither the name of the authors, the copyright holders or any contributors may be used to endorse or promote any Derivatives from this Software without specific written permission. Any attempt to deal with the Software which does not comply with this Licence shall be void and shall automatically terminate any rights granted under this licence (including any licence of any intellectual property rights granted herein). -Subject to the licences granted under this Licence any Contributor retains all rights, title and interest in and to any Derivatives made by Contributor subject to the underlying rights of XMOS in the Software. XMOS shall retain all rights, title and interest in the Software and any Derivatives made by XMOS (“XMOS Derivatives”). XMOS Derivatives will not automatically be subject to this Licence and XMOS shall be entitled to licence such rights on any terms (without obligation) as it sees fit. - -**8. Termination** - -8.1 This Licence will automatically terminate immediately, without notice to you, if: - -(a) you fail to comply with the terms of this Licence; and/or - -(b) you directly or indirectly commence any action for patent or intellectual property right infringement against XMOS, or any parent, group, affiliate or subsidiary of XMOS; provided XMOS did not first commence an action or patent infringement against you in that instance; and/or - -(c) the terms of this Licence are held by any court of competent jurisdiction to be unenforceable in whole or in part. - -**9. Critical Applications.** Unless XMOS has agreed in writing with you an agreement specifically governing use of the Goods in military, aerospace, automotive or medically related functions (collectively and individually hereinafter referred to as "Special Use"), any permitted use of the Software excludes Special Use. Notwithstanding any agreement between XMOS and you for Special Use, Special Use shall be at your own risk, and you shall fully indemnify XMOS against any damages, losses, costs and claims (direct and indirect) arising out of any Special Use. - -**10. NO WARRANTY OR SUPPORT.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL XMOS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, WARRANTY, CIVIL TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE INCLUDING GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES EVEN IF SUCH PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOT WITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE. IN SOME JURISDICTIONS PARTIES ARE UNABLE TO LIMIT LIABILTY IN THIS WAY, IF THIS APPLIES TO YOUR JURISDICTION THIS LIABILITY CLAUSE ABOVE MAY NOT APPLY. NOTWITHSTANDING THE ABOVE, IN NO EVENT SHALL XMOS’s TOTAL LIABILITY TO YOU FOR ALL DAMAGES, LOSS OR OTHERWISE EXCEED $50. - -**11. Governing Law and Jurisdiction.** This Licence constitutes the entire agreement between the parties with respect to the subject matter hereof. The Licence shall be governed by the laws of England and the conflict of laws and UN Convention on Contracts for the International Sale of Goods, shall not apply. diff --git a/examples/AN00220_app_phase_aligned_example/MIC-ARRAY-1V0.xn b/examples/AN00220_app_phase_aligned_example/MIC-ARRAY-1V0.xn deleted file mode 100644 index e8efb894..00000000 --- a/examples/AN00220_app_phase_aligned_example/MIC-ARRAY-1V0.xn +++ /dev/null @@ -1,115 +0,0 @@ - - - Board - XS2 MC Audio - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00220_app_phase_aligned_example/Makefile b/examples/AN00220_app_phase_aligned_example/Makefile deleted file mode 100644 index 6bc317ea..00000000 --- a/examples/AN00220_app_phase_aligned_example/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = MIC-ARRAY-1V0 - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = app_phase_aligned_example - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array(>=3.0.0) - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/examples/AN00220_app_phase_aligned_example/README.rst b/examples/AN00220_app_phase_aligned_example/README.rst deleted file mode 100644 index bf80b7f4..00000000 --- a/examples/AN00220_app_phase_aligned_example/README.rst +++ /dev/null @@ -1,34 +0,0 @@ -Microphone array phase-aligned capture example -============================================== - -Summary -------- - -This example demonstrates how to use the microphone array library to capture samples from the -microphone array and present them simultaneously with equal phase delay on each sample. The example -is designed to show up to 8 channel array processing. - -Software dependencies -..................... - -For a list of direct dependencies, look for USED_MODULES in the Makefile. - -Required hardware -................. - -This is an example only with no hardware requirements. - -Prerequisites -............. - - * This document assumes familiarity with the XMOS xCORE architecture, - the XMOS tool chain and the xC language. Documentation related to these - aspects which are not specific to this application note are linked to in - the references appendix. - - * The ``lib_mic_array`` user guide should be thoroughly read and understood. - - * For a description of XMOS related terms found in this document - please see the XMOS Glossary [#]_. - -.. [#] http://www.xmos.com/published/glossary diff --git a/examples/AN00220_app_phase_aligned_example/doc/rst/AN00220.rst b/examples/AN00220_app_phase_aligned_example/doc/rst/AN00220.rst deleted file mode 100644 index c2804e03..00000000 --- a/examples/AN00220_app_phase_aligned_example/doc/rst/AN00220.rst +++ /dev/null @@ -1,243 +0,0 @@ -.. include:: ../../README.rst - -|newpage| - -Overview --------- - -Introduction -............ - -This demo application shows the minimum code to interface to the microphone array. - -Block diagram -............. - -.. figure:: block_diagram.pdf - :width: 80% - - Application block diagram - -How to use lib_mic_array ------------------------- - -The Makefile -............ - -To start using the microphone array library you need to -add ``lib_mic_array`` to you Makefile:: - - USED_MODULES = .. lib_mic_array ... - -Includes -........ - -This application requires the system headers that defines XMOS xCORE specific -defines for declaring and initialising hardware: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: include - :end-on: include - -The microphone array library functions are defined in ``lib_mic_array.h``. This header must -be included in your code to use the library. The support functions for the board are defined in -``mic_array_board_support.h`` and the logging functions are provided by ``debug_print.h``. - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: include "mic_array.h" - :end-before: in port p_pdm_clk - -Allocating hardware resources -............................. - -A PDM microphone requires a clock and a data pin. For eight PDM microphones a single -clock can be shared between all microphones and the data can be sampled on a single -8 bit port. On an xCORE the pins are controlled by ``ports``. The application therefore -declares one 1-bit port and one 8-bit port: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: in port p_pdm_clk - :end-on: in buffered port:32 p_pdm_mics - -To generate the PDM clock a 24.576MHz master clock is divided by 8 using a clock block. These two hardware -resources are declared with: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: in port p_mclk - :end-on: clock pdmclk - -and are configured with: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: configure_clock_src_divide(pdmclk - :end-on: start_clock(pdmclk); - -The result begin a 3.072MHz PDM clock is used for clocking the microphone data into the xCORE. - - -Task setup ----------- - -The PDM microphones interface task and the decimators have to be connected -together and to the application (``example()``). There needs to be one -``mic_array_decimate_to_pcm_4ch()`` task per four channels that need processing. -The PDM interface task, ``mic_array_pdm_rx()`` can process eight channels so only -one is needed for this application. The PDM interface needs to be connected to the two -decimators via streaming channels. Finally, the decimators have to be connected to -the application. - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: streaming chan c_pdm_to_dec - :end-before: return 0; - -Note that the decimators have to be on the same tile as the application due to shared frame memory. - -Frame memory ------------- - -For each decimator an block of memory must be allocated for storing FIR data. The size of the data -block must be:: - - Number of channels for that decimator * THIRD_STAGE_COEFS_PER_STAGE * Decimation factor * sizeof(int) - -bytes. The data must also be double word aligned. For example: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: int data[ - :end-before: void example - -Note that on the xCORE-200 all global arrays are guaranteed to be double-word aligned. - -Configuration -------------- - -Configuration of the microphone array for the example is achieved through: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: mic_array_decimator_conf_common_t dcc - :end-before: mic_array_init_time_domain_frame - -All configuration options are described in the Microphone array library guide. Once configured -then the decimators require initialization via: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: mic_array_init_time_domain_frame - :end-before: while(1) - -The decimators will start presenting samples in the form of frames that can be accessed with: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: mic_array_frame_time_domain * current = - :end-on: mic_array_get_next_time_domain_frame - -The return value of ``mic_array_get_next_time_domain_frame()`` is a pointer to the frame that -the application is allowed to access. The ``current`` frame contains the frame data in the -``data`` member. ``data`` is a 2D array with the first index denoting the channel number and -the second index denoting the frame index. The frame index used 0 for the oldest samples and -increasing indices for newer samples. - -Changing the sample rate -........................ - -The sample rate chane be change easily with the example code by modifying: - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: #define DECIMATION_FACTOR - :end-before: #define DECIMATOR_COUNT - -The supported ``DECIMATION_FACTORS`` that come as standard from ``lib_mic_array`` are 2, 4, 6, 8 and 12. These -correspond to 48kHz, 24kHz, 16kHz, 12kHz, 8kHz and 6kHz. In order to change the define successfully you must -also ensure that the coefficients to the decimators are correct for the selected decimation factor. -The coefficients are declared in the header ``fir_coefs.h`` which is included in ``mic_array.h``. The ``coefs`` -member of ``mic_array_decimator_config_common`` must match the ``output_decimation_factor`` member. Also, -the FIR compensation must be made to match. For example, to change to 24kHz output, the config should look like:: - - mic_array_decimator_config_common dcc = { - 0, // Frame size log 2 is set to 0, i.e. one sample per channel will be present in each frame - 1, // DC offset elimination is turned on - 0, // Index bit reversal is off - 0, // No windowing function is being applied - 4,// The decimation factor is set to 6 - g_third_stage_div_4_fir, // This corresponds to a 24kHz output hence this coef array is used - 0, // Gain compensation is turned off - FIR_COMPENSATOR_DIV_4, // FIR compensation is set to the corresponding coefficients - DECIMATOR_NO_FRAME_OVERLAP, // Frame overlapping is turned off - FRAME_BUFFER_COUNT // The number of buffers in the audio array - }; - -Changing the frame buffer count -............................... - -The number of frame buffer in use can be modified through the define - -.. literalinclude:: app_phase_aligned_example.xc - :start-on: #define FRAME_BUFFER_COUNT 2 - :end-before: #define DECIMATOR_CH_COUNT 4 - -within this application. Increasing this would allow sample to be known for a longer period of time -before the memory is reused for the present samples at the cost of increased memory usage. - - -Changing the frame size -....................... - -The length of a frame is an arbitrary value < 2**15. The maximum allowed at run time is given by two to the -power of ``MIC_ARRAY_MAX_FRAME_SIZE_LOG2``. At run time the length can be dynamically configured by -setting the ``len`` member of ``mic_array_decimator_config_common``. If ``len`` -is less than 16, the frame size will be ``2^len``. If ``len`` is 16 or greater, the -frame size will be ``len``. - -Changing the buffering type -........................... - -The buffering type can be either ``DECIMATOR_NO_FRAME_OVERLAP`` or ``DECIMATOR_HALF_FRAME_OVERLAP``. -This is configured through the ``buffering_type`` member of ``mic_array_decimator_config_common``. -In half frame overlap mode the rate that the ``mic_array_get_next_time_domain_frame()`` function must -be serviced is doubled. - -Disabling the DC offset elimination -................................... - -The DC offset elimination can be disabled by configuring the ``mic_array_decimator_config_common`` with -0 in the ``apply_dc_offset_removal`` member. Setting ``apply_dc_offset_removal`` to non-zero will enable -it. - -Enabling microphone gain compensation -..................................... - -To enable the microphone gain compensation first the ``apply_mic_gain_compensation`` member of -``mic_array_decimator_config_common`` must be set to non-zero. Then for each ``mic_array_decimator_config`` -structure used to configure a 4 channel decimator the array member ``mic_gain_compensation`` must be set. -If the gain a microphone i is g\ :sub:`i`\, then the compensation factor should be -``INT_MAX`` / min(g\ :sub:`i`\) for each microphone i. - -References ----------- - -.. nopoints:: - - * XMOS Tools User Guide - - http://www.xmos.com/published/xtimecomposer-user-guide - - * XMOS xCORE Programming Guide - - http://www.xmos.com/published/xmos-programming-guide - - * XMOS Microphone Array Library - - http://www.xmos.com/support/libraries/lib_mic_array - - -|newpage| - -Full source code listing ------------------------- - -Source code for app_phase_aligned_example.xc -.................................................... - -.. literalinclude:: app_phase_aligned_example.xc - :largelisting: - -|newpage| diff --git a/examples/AN00220_app_phase_aligned_example/doc/rst/block_diagram.dot b/examples/AN00220_app_phase_aligned_example/doc/rst/block_diagram.dot deleted file mode 100644 index 773110cf..00000000 --- a/examples/AN00220_app_phase_aligned_example/doc/rst/block_diagram.dot +++ /dev/null @@ -1,17 +0,0 @@ -digraph g { - - mic_array_pdm_rx [label="mic_array_pdm_rx()", color=red]; - mic_array_decimate_to_pcm_4ch1 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - mic_array_decimate_to_pcm_4ch0 [label="mic_array_decimate_to_pcm_4ch()", color=red]; - example [label="example()", color=red]; - - pdm_mic [label="PDM Microphone", shape=box]; - - pdm_mic -> mic_array_pdm_rx; - - mic_array_pdm_rx -> mic_array_decimate_to_pcm_4ch0; - mic_array_pdm_rx -> mic_array_decimate_to_pcm_4ch1; - - mic_array_decimate_to_pcm_4ch0 -> example; - mic_array_decimate_to_pcm_4ch1 -> example; -} diff --git a/examples/AN00220_app_phase_aligned_example/doc/rst/block_diagram.pdf b/examples/AN00220_app_phase_aligned_example/doc/rst/block_diagram.pdf deleted file mode 100644 index ebff8fc6..00000000 Binary files a/examples/AN00220_app_phase_aligned_example/doc/rst/block_diagram.pdf and /dev/null differ diff --git a/examples/AN00220_app_phase_aligned_example/doc/rst/xdoc.conf b/examples/AN00220_app_phase_aligned_example/doc/rst/xdoc.conf deleted file mode 100644 index 37460abf..00000000 --- a/examples/AN00220_app_phase_aligned_example/doc/rst/xdoc.conf +++ /dev/null @@ -1,2 +0,0 @@ -XMOSNEWSTYLE=1 -SOURCE_INCLUDE_DIRS=../../src \ No newline at end of file diff --git a/examples/AN00220_app_phase_aligned_example/src/app_phase_aligned_example.xc b/examples/AN00220_app_phase_aligned_example/src/app_phase_aligned_example.xc deleted file mode 100644 index e5eb5802..00000000 --- a/examples/AN00220_app_phase_aligned_example/src/app_phase_aligned_example.xc +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include - -#include "mic_array.h" - -on tile[0]: out port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -#define DECIMATION_FACTOR 6 //Corresponds to a 16kHz output sample rate -#define DECIMATOR_COUNT 2 //8 channels requires 2 decimators -#define FRAME_BUFFER_COUNT 2 //The minimum of 2 will suffice for this example - -#define DECIMATOR_CH_COUNT 4 //Just to be clear - -int data[DECIMATOR_COUNT*DECIMATOR_CH_COUNT] - [THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR]; - -void example(streaming chanend c_ds_output[DECIMATOR_COUNT]) { - unsafe{ - mic_array_frame_time_domain audio[FRAME_BUFFER_COUNT]; - - unsigned buffer; //No need to initialize this. - memset(data, 0, DECIMATOR_COUNT*DECIMATOR_CH_COUNT* - THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR*sizeof(int)); - - mic_array_decimator_conf_common_t dcc = { - 0, // Frame size log 2 is set to 0, i.e. one sample per channel will be present in each frame - 1, // DC offset elimination is turned on - 0, // Index bit reversal is off - 0, // No windowing function is being applied - DECIMATION_FACTOR,// The decimation factor is set to 6 - g_third_stage_div_6_fir, // This corresponds to a 16kHz output hence this coef array is used - 0, // Gain compensation is turned off - FIR_COMPENSATOR_DIV_6, // FIR compensation is set to the corresponding coefficients - DECIMATOR_NO_FRAME_OVERLAP, // Frame overlapping is turned off - FRAME_BUFFER_COUNT // The number of buffers in the audio array - }; - - mic_array_decimator_config_t dc[DECIMATOR_COUNT] = { - { - &dcc, - data[0], // The storage area for the output decimator - {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, // Microphone gain compensation (turned off) - 4, // Enabled channel count (currently must be 4) - 0, // Disable async interface - }, - { - &dcc, - data[4], // The storage area for the output decimator - {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, // Microphone gain compensation (turned off) - 4, // Enabled channel count (currently must be 4) - 0, // Disable async interface - } - }; - mic_array_decimator_configure(c_ds_output, DECIMATOR_COUNT, dc); - - mic_array_init_time_domain_frame(c_ds_output, DECIMATOR_COUNT, buffer, audio, dc); - - while(1){ - mic_array_frame_time_domain * current = - mic_array_get_next_time_domain_frame(c_ds_output, DECIMATOR_COUNT, buffer, audio, dc); - - } - } -} - -int main(){ - par{ - on tile[0]:{ - configure_clock_src_divide(pdmclk, p_mclk, 4); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - streaming chan c_pdm_to_dec[DECIMATOR_COUNT]; - streaming chan c_ds_output[DECIMATOR_COUNT]; - - par{ - mic_array_pdm_rx(p_pdm_mics, c_pdm_to_dec[0], c_pdm_to_dec[1]); - mic_array_decimate_to_pcm_4ch(c_pdm_to_dec[0], c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_pdm_to_dec[1], c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - example(c_ds_output); - } - } - } - return 0; -} diff --git a/examples/AN00220_app_phase_aligned_example/src/mic_array_conf.h b/examples/AN00220_app_phase_aligned_example/src/mic_array_conf.h deleted file mode 100644 index 6ed389be..00000000 --- a/examples/AN00220_app_phase_aligned_example/src/mic_array_conf.h +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 8 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/examples/AN00221_freq_domain_example/.cproject b/examples/AN00221_freq_domain_example/.cproject deleted file mode 100644 index 5933da0b..00000000 --- a/examples/AN00221_freq_domain_example/.cproject +++ /dev/null @@ -1,1001 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/examples/AN00221_freq_domain_example/.project b/examples/AN00221_freq_domain_example/.project deleted file mode 100644 index 0739d1fd..00000000 --- a/examples/AN00221_freq_domain_example/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - AN00221_freq_domain_example - - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/examples/AN00221_freq_domain_example/LICENSE.rst b/examples/AN00221_freq_domain_example/LICENSE.rst deleted file mode 100644 index ca48f20f..00000000 --- a/examples/AN00221_freq_domain_example/LICENSE.rst +++ /dev/null @@ -1,84 +0,0 @@ -******************************* -XMOS PUBLIC LICENCE: Version 1 -******************************* - -Subject to the conditions and limitations below, permission is hereby granted by XMOS LIMITED (“XMOS”), free of charge, to any person or entity obtaining a copy of the XMOS Software. - -**1. Definitions** - -**“Applicable Patent Rights”** means: (a) where XMOS is the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to XMOS and (ii) that cover subject matter contained in the Software, but only to the extent it is necessary to use, reproduce or distribute the Software without infringement; and (b) where you are the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to you and (ii) that cover the subject matter contained in your Derivatives, taken alone or in combination with the Software. - -**“Compiled Code”** means any compiled, binary, machine readable or executable version of the Source Code. - -**“Contributor”** means any person or entity that creates or contributes to the creation of Derivatives. - -**“Derivatives”** means any addition to, deletion from and/or change to the substance, structure of the Software, any previous Derivatives, the combination of the Derivatives and the Software and/or any respective portions thereof. - -**“Source Code”** means the human readable code that is suitable for making modifications but excluding any Compiled Code. - -**“Software”** means the software and associated documentation files which XMOS makes available and which contain a notice identifying the software as original XMOS software and referring to the software being subject to the terms of this XMOS Public Licence. - -This Licence refers to XMOS Software and does not relate to any XMOS hardware or devices which are protected by intellectual property rights (including patent and trade marks) which may be sold to you under a separate agreement. - - -**2. Licence** - -**Permitted Uses, Conditions and Restrictions.** Subject to the conditions below, XMOS grants you a worldwide, royalty free, non-exclusive licence, to the extent of any Patent Rights to do the following: - -2.1 **Unmodified Software.** You may use, copy, display, publish, distribute and make available unmodified copies of the Software: - -2.1.1 for personal or academic, non-commercial purposes; or - -2.1.2 for commercial purposes provided the Software is at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.1.1 and 2.1.2): - -(a) you must retain and reproduce in all copies of the Software the copyright and proprietary notices and disclaimers of XMOS as they appear in the Software, and keep intact all notices and disclaimers in the Software files that refer to this Licence; and - -(b) you must include a copy of this Licence with every copy of the Software and documentation you publish, distribute and make available and you may not offer or impose any terms on such Software that alter or restrict this Licence or the intent of such Licence, except as permitted below (Additional Terms). - -The licence above does not include any Compiled Code which XMOS may make available under a separate support and licence agreement. - -2.2 **Derivatives.** You may create and modify Derivatives and use, copy, display, publish, distribute and make available Derivatives: - -2.2.1 for personal or academic, non-commercial purposes; or - -2.2.2 for commercial purposes, provided the Derivatives are at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.2.1 and 2.2.2): - -(a) you must comply with the terms of clause 2.1 with respect to the Derivatives; - -(b) you must copy (to the extent it doesn’t already exist) the notice below in each file of the Derivatives, and ensure all the modified files carry prominent notices stating that you have changed the files and the date of any change; and - -(c) if you sublicence, distribute or otherwise make the Software and/or the Derivatives available for commercial purposes, you must provide that the Software and Derivatives are at all times used on a device designed, licensed or developed by XMOS. - -Without limitation to these terms and clause 3 below, the Source Code and Compiled Code to your Derivatives may at your discretion (but without obligation) be released, copied, displayed, published, distributed and made available; and if you elect to do so, it must be under the terms of this Licence including the terms of the licence at clauses 2.2.1, 2.2.2 and clause 3 below. - -2.3 **Distribution of Executable Versions.** If you distribute or make available Derivatives, you must include a prominent notice in the code itself as well as in all related documentation, stating that the Source Code of the Software from which the Derivatives are based is available under the terms of this Licence, with information on how and where to obtain such Source Code. - -**3. Your Grant of Rights.** In consideration and as a condition to this Licence, you grant to any person or entity receiving or distributing any Derivatives, a non-exclusive, royalty free, perpetual, irrevocable license under your Applicable Patent Rights and all other intellectual property rights owned or controlled by you, to use, copy, display, publish, distribute and make available your Derivatives of the same scope and extent as XMOS’s licence under clause 2.2 above. - -**4. Combined Products.** You may create a combined product by combining Software, Derivatives and other code not covered by this Licence as a single application or product. In such instance, you must comply with the requirements of this Licence for any portion of the Software and/or Derivatives. - -**5. Additional Terms.** You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the term of this Licence (“Additional Terms”) to any legitimate recipients of the Software and/or Derivatives. The terms on which you provide such Additional Terms are on your sole responsibility and you shall indemnify, defend and hold XMOS harmless against any claims asserted against XMOS. - -**6. New Versions.** XMOS may publish revised and/or new versions of this Licence from time to time to accommodate changes to the Licence terms, new versions, updates and bug fixes of the Software. Each version will be given a distinguishing version number. Once Software has been published under a particular version of this Licence, you may continue to use it under the terms of that version. You may also choose to use the latest version of the Software under any subsequent version published by XMOS. Only XMOS shall have the right to modify these terms. - -**7. IPR and Ownership** -Any rights, including all intellectual property rights and all trademarks not expressly granted herein are reserved in full by the authors or copyright holders. Any requests for additional permissions by XMOS including any rights to use XMOS trademarks, should be made (without obligation) to XMOS at **support@xmos.com** - -Nothing herein shall limit any rights that XMOS is otherwise entitled to under the doctrines of patent exhaustion, implied license, or legal estoppel. Neither the name of the authors, the copyright holders or any contributors may be used to endorse or promote any Derivatives from this Software without specific written permission. Any attempt to deal with the Software which does not comply with this Licence shall be void and shall automatically terminate any rights granted under this licence (including any licence of any intellectual property rights granted herein). -Subject to the licences granted under this Licence any Contributor retains all rights, title and interest in and to any Derivatives made by Contributor subject to the underlying rights of XMOS in the Software. XMOS shall retain all rights, title and interest in the Software and any Derivatives made by XMOS (“XMOS Derivatives”). XMOS Derivatives will not automatically be subject to this Licence and XMOS shall be entitled to licence such rights on any terms (without obligation) as it sees fit. - -**8. Termination** - -8.1 This Licence will automatically terminate immediately, without notice to you, if: - -(a) you fail to comply with the terms of this Licence; and/or - -(b) you directly or indirectly commence any action for patent or intellectual property right infringement against XMOS, or any parent, group, affiliate or subsidiary of XMOS; provided XMOS did not first commence an action or patent infringement against you in that instance; and/or - -(c) the terms of this Licence are held by any court of competent jurisdiction to be unenforceable in whole or in part. - -**9. Critical Applications.** Unless XMOS has agreed in writing with you an agreement specifically governing use of the Goods in military, aerospace, automotive or medically related functions (collectively and individually hereinafter referred to as "Special Use"), any permitted use of the Software excludes Special Use. Notwithstanding any agreement between XMOS and you for Special Use, Special Use shall be at your own risk, and you shall fully indemnify XMOS against any damages, losses, costs and claims (direct and indirect) arising out of any Special Use. - -**10. NO WARRANTY OR SUPPORT.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL XMOS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, WARRANTY, CIVIL TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE INCLUDING GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES EVEN IF SUCH PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOT WITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE. IN SOME JURISDICTIONS PARTIES ARE UNABLE TO LIMIT LIABILTY IN THIS WAY, IF THIS APPLIES TO YOUR JURISDICTION THIS LIABILITY CLAUSE ABOVE MAY NOT APPLY. NOTWITHSTANDING THE ABOVE, IN NO EVENT SHALL XMOS’s TOTAL LIABILITY TO YOU FOR ALL DAMAGES, LOSS OR OTHERWISE EXCEED $50. - -**11. Governing Law and Jurisdiction.** This Licence constitutes the entire agreement between the parties with respect to the subject matter hereof. The Licence shall be governed by the laws of England and the conflict of laws and UN Convention on Contracts for the International Sale of Goods, shall not apply. diff --git a/examples/AN00221_freq_domain_example/MIC-ARRAY-1V0.xn b/examples/AN00221_freq_domain_example/MIC-ARRAY-1V0.xn deleted file mode 100644 index e8efb894..00000000 --- a/examples/AN00221_freq_domain_example/MIC-ARRAY-1V0.xn +++ /dev/null @@ -1,115 +0,0 @@ - - - Board - XS2 MC Audio - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00221_freq_domain_example/Makefile b/examples/AN00221_freq_domain_example/Makefile deleted file mode 100644 index 1815103c..00000000 --- a/examples/AN00221_freq_domain_example/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = AN00221_freq_domain_example - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_i2c(>=4.0.0) lib_i2s(>=2.2.0) lib_dsp(>=3.0.0) lib_mic_array(>=3.0.0) lib_mic_array_board_support(>=2.1.0) - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g -report - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/examples/AN00221_freq_domain_example/README.rst b/examples/AN00221_freq_domain_example/README.rst deleted file mode 100644 index e367f285..00000000 --- a/examples/AN00221_freq_domain_example/README.rst +++ /dev/null @@ -1,34 +0,0 @@ -Efficient frequency domain audio processing -=========================================== - -Summary -------- - -This example demonstrates blockwise DSP processing of audio samples received from the PDM-to-PCM decimator. The samples are received through a double buffer. The decimator can be configured to output the samples indexed in bit reversed order enabling direct processing by an FFT. The frequeny domain signals are then processed for channel 0 (low pass) and channel 1 (high pass). Subsequently the inverse FFT is performed on channel 0 and channel 1 before the samples are output over I2S to a DAC. - - -Software dependencies -..................... - -For a list of direct dependencies, look for USED_MODULES in the Makefile. - -Required hardware -................. - -The example code provided with the application has been implemented -and tested on the Microphone Array Ref Design v1. - -Prerequisites -............. - - * This document assumes familiarity with the XMOS xCORE architecture, - the XMOS tool chain and the xC language. Documentation related to these - aspects which are not specific to this application note are linked to in - the references appendix. - - * The ``lib_mic_array`` user guide should be thoroughly read and understood. - - * For a description of XMOS related terms found in this document - please see the XMOS Glossary [#]_. - -.. [#] http://www.xmos.com/published/glossary diff --git a/examples/AN00221_freq_domain_example/config.xscope b/examples/AN00221_freq_domain_example/config.xscope deleted file mode 100644 index 99f700c8..00000000 --- a/examples/AN00221_freq_domain_example/config.xscope +++ /dev/null @@ -1,24 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/AN00221_freq_domain_example/doc/rst/AN00221.rst b/examples/AN00221_freq_domain_example/doc/rst/AN00221.rst deleted file mode 100644 index 69ba18b1..00000000 --- a/examples/AN00221_freq_domain_example/doc/rst/AN00221.rst +++ /dev/null @@ -1,12 +0,0 @@ -.. include:: ../../README.rst - -|newpage| - -Overview --------- - - - - - -|newpage| diff --git a/examples/AN00221_freq_domain_example/doc/rst/xdoc.conf b/examples/AN00221_freq_domain_example/doc/rst/xdoc.conf deleted file mode 100644 index 37460abf..00000000 --- a/examples/AN00221_freq_domain_example/doc/rst/xdoc.conf +++ /dev/null @@ -1,2 +0,0 @@ -XMOSNEWSTYLE=1 -SOURCE_INCLUDE_DIRS=../../src \ No newline at end of file diff --git a/examples/AN00221_freq_domain_example/src/app_freq_domain_example.xc b/examples/AN00221_freq_domain_example/src/app_freq_domain_example.xc deleted file mode 100644 index 3406adc0..00000000 --- a/examples/AN00221_freq_domain_example/src/app_freq_domain_example.xc +++ /dev/null @@ -1,377 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. - -#include -#include -#include -#include -#include -#include -#include - -#include "i2c.h" -#include "i2s.h" -#include "mic_array.h" -#include "mic_array_board_support.h" -#include "dsp.h" - -#define DECIMATION_FACTOR 2 //Corresponds to a 48kHz output sample rate -#define DECIMATOR_COUNT 2 //8 channels requires 2 decimators -#define NUM_FRAME_BUFFERS 3 //Triple buffer needed for overlapping frames -#define NUM_OUTPUT_CHANNELS 2 - -//Ports for the PDM microphones -on tile[0]: out port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -//Ports for the DAC and clocking -out buffered port:32 p_i2s_dout[1] = on tile[1]: {XS1_PORT_1P}; -in port p_mclk_in1 = on tile[1]: XS1_PORT_1O; -out buffered port:32 p_bclk = on tile[1]: XS1_PORT_1M; -out buffered port:32 p_lrclk = on tile[1]: XS1_PORT_1N; -port p_i2c = on tile[1]: XS1_PORT_4E; // Bit 0: SCLK, Bit 1: SDA -port p_rst_shared = on tile[1]: XS1_PORT_4F; // Bit 0: DAC_RST_N, Bit 1: ETH_RST_N -clock mclk = on tile[1]: XS1_CLKBLK_3; -clock bclk = on tile[1]: XS1_CLKBLK_4; - -//The number of bins in the FFT (defined in this case by -// MIC_ARRAY_MAX_FRAME_SIZE_LOG2 given in mic_array_conf.h) -#define FFT_N (1<>31); - t = (uint64_t)window[i] * (uint64_t)p[i].im; - p[i].im = (t>>31); - } - for(unsigned i=N/2;i>31); - t = (uint64_t)window[N-1-i] * (uint64_t)p[i].im; - p[i].im = (t>>31); - } -} - - -void freq_domain_example(streaming chanend c_ds_output[2], streaming chanend c_audio){ - - unsigned buffer ; - mic_array_frame_fft_preprocessed comp[NUM_FRAME_BUFFERS]; - - memset(data, 0, sizeof(int)*8*THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR); - - int window[FFT_N/2]; - for(unsigned i=0;idata[i] into p - dsp_fft_short_to_long(p, (dsp_complex_short_t*)current->data[i], FFT_N); - - //Apply one FFT to two channels at a time - dsp_fft_forward(p, FFT_N, dsp_sine_512); - //Reconstruct the two independent frequency domain representations - dsp_fft_split_spectrum(p, FFT_N); - // convert p back into current->data[i] - dsp_fft_long_to_short((dsp_complex_short_t*)current->data[i], p, FFT_N); -#else - //Apply one FFT to two channels at a time - dsp_fft_forward((dsp_complex_t*)current->data[i], FFT_N, dsp_sine_512); - - //Reconstruct the two independent frequency domain representations - dsp_fft_split_spectrum((dsp_complex_t*)current->data[i], FFT_N); -#endif - } - mic_array_frame_frequency_domain * frequency = (mic_array_frame_frequency_domain*)current; - - - /* - *Work in the frequency domain here: - */ - - //For example, low pass filter of channel 0 - //cutoff Frequency = (Fs/FFT_N * cutoff_index) - //With cutoff_index = FFT_N/M: - //cut off Frequency = Fs/M - //e.g. Fs = 16kHz, M=4: cutoff frequency = 4kHz - for(unsigned i = FFT_N/4; i < FFT_N/2; i++){ - frequency->data[0][i].re = 0; - frequency->data[0][i].im = 0; - } - //Don't forget the nyquest rate - frequency->data[0][0].im = 0; - - - //For example, high pass filter of channel 1 - //Same cutoff frequency as above - frequency->data[1][0].re = 0; - for(unsigned i = 1; i < FFT_N/4; i++){ - frequency->data[1][i].re = 0; - frequency->data[1][i].im = 0; - } - - //Now to get channel 0 and channel 1 back to the time domain= -#if MIC_ARRAY_WORD_LENGTH_SHORT - // Note! frequency is an alias of current. current->data[0] has frequency->data[0] and frequency->data[1] - // So we can convert directly into p - dsp_fft_short_to_long(p, (dsp_complex_short_t*)current->data[0], FFT_N); // convert into tmp buffer -#else - memcpy(&p[0], frequency->data[0], sizeof(dsp_complex_t)*FFT_N/2); - memcpy(&p[FFT_N/2], frequency->data[1], sizeof(dsp_complex_t)*FFT_N/2); -#endif - - dsp_fft_merge_spectra(p, FFT_N); - dsp_fft_bit_reverse(p, FFT_N); - dsp_fft_inverse(p, FFT_N, dsp_sine_512); - //Now the p array is a time domain representation of the selected channel. - // -The imaginary component will be the channel 1 time domain representation. - // -The real component will be the channel 0 time domain representation. - - apply_window_function(p, window, FFT_N); - - for(unsigned i=0; i c_audio :> sample: - //if(sample_idx == 0 && !buffer_get_next_bufped_flag) { - //printf("Buffer overflow\n"); - //}; - unsigned channel_idx = count & 1; - if(sample_idxdata[channel_idx][sample_idx] = sample; - } else { - // second half - triple_buffer[(head+1)%NUM_FRAME_BUFFERS].data[channel_idx][sample_idx-(FFT_N/2)] = sample; - } - //buffer->data[channel_idx][sample_idx] = sample; - if(channel_idx==1) { - sample_idx++; - } - if(sample_idx>=FFT_N) { - sample_idx = 0; - buffer_full = 1; - //Manage overlapping buffers - head++; - if(head == NUM_FRAME_BUFFERS) - head = 0; - } - - count++; - break; - } - } -} -} - -#define MASTER_TO_PDM_CLOCK_DIVIDER 4 -#define MASTER_CLOCK_FREQUENCY 24576000 -#define PDM_CLOCK_FREQUENCY (MASTER_CLOCK_FREQUENCY/(2*MASTER_TO_PDM_CLOCK_DIVIDER)) -#define OUTPUT_SAMPLE_RATE (PDM_CLOCK_FREQUENCY/(32*DECIMATION_FACTOR)) - -unsafe { -[[distributable]] -void i2s_handler(server i2s_callback_if i2s, - client i2c_master_if i2c, - client interface bufget_i filler - ) { - multichannel_audio_block_s * unsafe buffer = 0; // invalid - unsigned sample_idx=0; - - p_rst_shared <: 0xF; - - mabs_init_pll(i2c, ETH_MIC_ARRAY); - - i2c_regop_res_t res; - int i = 0x4A; - - uint8_t data = 1; - res = i2c.write_reg(i, 0x02, data); // Power down - - data = 0x08; - res = i2c.write_reg(i, 0x04, data); // Slave, I2S mode, up to 24-bit - - data = 0; - res = i2c.write_reg(i, 0x03, data); // Disable Auto mode and MCLKDIV2 - - data = 0x00; - res = i2c.write_reg(i, 0x09, data); // Disable DSP - - data = 0; - res = i2c.write_reg(i, 0x02, data); // Power up - - while (1) { - select { - case i2s.init(i2s_config_t &?i2s_config, tdm_config_t &?tdm_config): - i2s_config.mode = I2S_MODE_I2S; - i2s_config.mclk_bclk_ratio = (MASTER_CLOCK_FREQUENCY/OUTPUT_SAMPLE_RATE)/64; - break; - - case i2s.restart_check() -> i2s_restart_t restart: - restart = I2S_NO_RESTART; - break; - - case i2s.receive(size_t index, int32_t sample): - break; - - case i2s.send(size_t index) -> int32_t sample: - if(buffer) { - sample = buffer->data[index][sample_idx]; - //printf("I2S send sample %d on channel %d\n",sample_idx,index); - } else { // buffer invalid - sample = 0; - } - //xscope_int(index, sample); - if(index == 1) { - sample_idx++; - } - if(sample_idx>=FFT_N/2) { - // end of buffer reached. - sample_idx = 0; - filler.get_next_buf(buffer); - //printf("I2S got next buffer at 0x%x\n", buffer); - } - break; - } - } -} -} - - -int main(){ - - streaming chan c_4x_pdm_mic_0, c_4x_pdm_mic_1; - streaming chan c_ds_output[2]; - - i2s_callback_if i_i2s; - i2c_master_if i_i2c[1]; - streaming chan c_audio; - - interface bufget_i bufget; - - par { - on tile[1]: { - configure_clock_src(mclk, p_mclk_in1); - start_clock(mclk); - i2s_master(i_i2s, p_i2s_dout, 1, null, 0, p_bclk, p_lrclk, bclk, mclk); - } - - on tile[1]: [[distribute]]i2c_master_single_port(i_i2c, 1, p_i2c, 100, 0, 1, 0); - on tile[1]: [[distribute]]i2s_handler(i_i2s, i_i2c[0], bufget); - on tile[1]: output_audio_dbuf_handler(bufget, triple_buffer, c_audio); - on tile[0]: { - configure_clock_src_divide(pdmclk, p_mclk, 4); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - par{ - mic_array_pdm_rx(p_pdm_mics, c_4x_pdm_mic_0, c_4x_pdm_mic_1); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic_0, c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic_1, c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - freq_domain_example(c_ds_output, c_audio); - //par(int i=0;i<4;i++)while(1); - } - } - } - return 0; -} - diff --git a/examples/AN00221_freq_domain_example/src/mic_array_conf.h b/examples/AN00221_freq_domain_example/src/mic_array_conf.h deleted file mode 100644 index 49f23ac1..00000000 --- a/examples/AN00221_freq_domain_example/src/mic_array_conf.h +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_WORD_LENGTH_SHORT 0 // 32 bit samples - -#if MIC_ARRAY_WORD_LENGTH_SHORT -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 9 // 512 FFT -#else -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 9 // 512 FFT -#endif -#define MIC_ARRAY_NUM_MICS 8 - -#if MIC_ARRAY_MAX_FRAME_SIZE_LOG2 > 9 -#error "Max value for MIC_ARRAY_MAX_FRAME_SIZE_LOG2 is 9. There is no audio for more than 512 (1<<9) FFT points" -#endif - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/examples/app_vu/.cproject b/examples/app_vu/.cproject deleted file mode 100644 index f94d7d21..00000000 --- a/examples/app_vu/.cproject +++ /dev/null @@ -1,998 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/examples/app_vu/.project b/examples/app_vu/.project deleted file mode 100644 index e8ab03b8..00000000 --- a/examples/app_vu/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - app_vu - - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/examples/app_vu/LICENSE.rst b/examples/app_vu/LICENSE.rst deleted file mode 100644 index ca48f20f..00000000 --- a/examples/app_vu/LICENSE.rst +++ /dev/null @@ -1,84 +0,0 @@ -******************************* -XMOS PUBLIC LICENCE: Version 1 -******************************* - -Subject to the conditions and limitations below, permission is hereby granted by XMOS LIMITED (“XMOS”), free of charge, to any person or entity obtaining a copy of the XMOS Software. - -**1. Definitions** - -**“Applicable Patent Rights”** means: (a) where XMOS is the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to XMOS and (ii) that cover subject matter contained in the Software, but only to the extent it is necessary to use, reproduce or distribute the Software without infringement; and (b) where you are the grantor of the rights, (i) claims of patents that are now or in future owned by or assigned to you and (ii) that cover the subject matter contained in your Derivatives, taken alone or in combination with the Software. - -**“Compiled Code”** means any compiled, binary, machine readable or executable version of the Source Code. - -**“Contributor”** means any person or entity that creates or contributes to the creation of Derivatives. - -**“Derivatives”** means any addition to, deletion from and/or change to the substance, structure of the Software, any previous Derivatives, the combination of the Derivatives and the Software and/or any respective portions thereof. - -**“Source Code”** means the human readable code that is suitable for making modifications but excluding any Compiled Code. - -**“Software”** means the software and associated documentation files which XMOS makes available and which contain a notice identifying the software as original XMOS software and referring to the software being subject to the terms of this XMOS Public Licence. - -This Licence refers to XMOS Software and does not relate to any XMOS hardware or devices which are protected by intellectual property rights (including patent and trade marks) which may be sold to you under a separate agreement. - - -**2. Licence** - -**Permitted Uses, Conditions and Restrictions.** Subject to the conditions below, XMOS grants you a worldwide, royalty free, non-exclusive licence, to the extent of any Patent Rights to do the following: - -2.1 **Unmodified Software.** You may use, copy, display, publish, distribute and make available unmodified copies of the Software: - -2.1.1 for personal or academic, non-commercial purposes; or - -2.1.2 for commercial purposes provided the Software is at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.1.1 and 2.1.2): - -(a) you must retain and reproduce in all copies of the Software the copyright and proprietary notices and disclaimers of XMOS as they appear in the Software, and keep intact all notices and disclaimers in the Software files that refer to this Licence; and - -(b) you must include a copy of this Licence with every copy of the Software and documentation you publish, distribute and make available and you may not offer or impose any terms on such Software that alter or restrict this Licence or the intent of such Licence, except as permitted below (Additional Terms). - -The licence above does not include any Compiled Code which XMOS may make available under a separate support and licence agreement. - -2.2 **Derivatives.** You may create and modify Derivatives and use, copy, display, publish, distribute and make available Derivatives: - -2.2.1 for personal or academic, non-commercial purposes; or - -2.2.2 for commercial purposes, provided the Derivatives are at all times used on a device designed, licensed or developed by XMOS and, provided that in each instance (2.2.1 and 2.2.2): - -(a) you must comply with the terms of clause 2.1 with respect to the Derivatives; - -(b) you must copy (to the extent it doesn’t already exist) the notice below in each file of the Derivatives, and ensure all the modified files carry prominent notices stating that you have changed the files and the date of any change; and - -(c) if you sublicence, distribute or otherwise make the Software and/or the Derivatives available for commercial purposes, you must provide that the Software and Derivatives are at all times used on a device designed, licensed or developed by XMOS. - -Without limitation to these terms and clause 3 below, the Source Code and Compiled Code to your Derivatives may at your discretion (but without obligation) be released, copied, displayed, published, distributed and made available; and if you elect to do so, it must be under the terms of this Licence including the terms of the licence at clauses 2.2.1, 2.2.2 and clause 3 below. - -2.3 **Distribution of Executable Versions.** If you distribute or make available Derivatives, you must include a prominent notice in the code itself as well as in all related documentation, stating that the Source Code of the Software from which the Derivatives are based is available under the terms of this Licence, with information on how and where to obtain such Source Code. - -**3. Your Grant of Rights.** In consideration and as a condition to this Licence, you grant to any person or entity receiving or distributing any Derivatives, a non-exclusive, royalty free, perpetual, irrevocable license under your Applicable Patent Rights and all other intellectual property rights owned or controlled by you, to use, copy, display, publish, distribute and make available your Derivatives of the same scope and extent as XMOS’s licence under clause 2.2 above. - -**4. Combined Products.** You may create a combined product by combining Software, Derivatives and other code not covered by this Licence as a single application or product. In such instance, you must comply with the requirements of this Licence for any portion of the Software and/or Derivatives. - -**5. Additional Terms.** You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the term of this Licence (“Additional Terms”) to any legitimate recipients of the Software and/or Derivatives. The terms on which you provide such Additional Terms are on your sole responsibility and you shall indemnify, defend and hold XMOS harmless against any claims asserted against XMOS. - -**6. New Versions.** XMOS may publish revised and/or new versions of this Licence from time to time to accommodate changes to the Licence terms, new versions, updates and bug fixes of the Software. Each version will be given a distinguishing version number. Once Software has been published under a particular version of this Licence, you may continue to use it under the terms of that version. You may also choose to use the latest version of the Software under any subsequent version published by XMOS. Only XMOS shall have the right to modify these terms. - -**7. IPR and Ownership** -Any rights, including all intellectual property rights and all trademarks not expressly granted herein are reserved in full by the authors or copyright holders. Any requests for additional permissions by XMOS including any rights to use XMOS trademarks, should be made (without obligation) to XMOS at **support@xmos.com** - -Nothing herein shall limit any rights that XMOS is otherwise entitled to under the doctrines of patent exhaustion, implied license, or legal estoppel. Neither the name of the authors, the copyright holders or any contributors may be used to endorse or promote any Derivatives from this Software without specific written permission. Any attempt to deal with the Software which does not comply with this Licence shall be void and shall automatically terminate any rights granted under this licence (including any licence of any intellectual property rights granted herein). -Subject to the licences granted under this Licence any Contributor retains all rights, title and interest in and to any Derivatives made by Contributor subject to the underlying rights of XMOS in the Software. XMOS shall retain all rights, title and interest in the Software and any Derivatives made by XMOS (“XMOS Derivatives”). XMOS Derivatives will not automatically be subject to this Licence and XMOS shall be entitled to licence such rights on any terms (without obligation) as it sees fit. - -**8. Termination** - -8.1 This Licence will automatically terminate immediately, without notice to you, if: - -(a) you fail to comply with the terms of this Licence; and/or - -(b) you directly or indirectly commence any action for patent or intellectual property right infringement against XMOS, or any parent, group, affiliate or subsidiary of XMOS; provided XMOS did not first commence an action or patent infringement against you in that instance; and/or - -(c) the terms of this Licence are held by any court of competent jurisdiction to be unenforceable in whole or in part. - -**9. Critical Applications.** Unless XMOS has agreed in writing with you an agreement specifically governing use of the Goods in military, aerospace, automotive or medically related functions (collectively and individually hereinafter referred to as "Special Use"), any permitted use of the Software excludes Special Use. Notwithstanding any agreement between XMOS and you for Special Use, Special Use shall be at your own risk, and you shall fully indemnify XMOS against any damages, losses, costs and claims (direct and indirect) arising out of any Special Use. - -**10. NO WARRANTY OR SUPPORT.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL XMOS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, WARRANTY, CIVIL TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE INCLUDING GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES EVEN IF SUCH PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOT WITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE. IN SOME JURISDICTIONS PARTIES ARE UNABLE TO LIMIT LIABILTY IN THIS WAY, IF THIS APPLIES TO YOUR JURISDICTION THIS LIABILITY CLAUSE ABOVE MAY NOT APPLY. NOTWITHSTANDING THE ABOVE, IN NO EVENT SHALL XMOS’s TOTAL LIABILITY TO YOU FOR ALL DAMAGES, LOSS OR OTHERWISE EXCEED $50. - -**11. Governing Law and Jurisdiction.** This Licence constitutes the entire agreement between the parties with respect to the subject matter hereof. The Licence shall be governed by the laws of England and the conflict of laws and UN Convention on Contracts for the International Sale of Goods, shall not apply. diff --git a/examples/app_vu/MIC-ARRAY-1V0.xn b/examples/app_vu/MIC-ARRAY-1V0.xn deleted file mode 100644 index e8efb894..00000000 --- a/examples/app_vu/MIC-ARRAY-1V0.xn +++ /dev/null @@ -1,115 +0,0 @@ - - - Board - XS2 MC Audio - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/app_vu/Makefile b/examples/app_vu/Makefile deleted file mode 100644 index b7bc6245..00000000 --- a/examples/app_vu/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = MIC-ARRAY-1V0 - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = app_vu - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_i2c(>=4.0.0) lib_i2s(>=2.2.0) lib_mic_array(>=3.0.0) lib_mic_array_board_support(>=2.1.0) - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/examples/app_vu/config.xscope b/examples/app_vu/config.xscope deleted file mode 100644 index 532763c5..00000000 --- a/examples/app_vu/config.xscope +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/app_vu/db_meter.py b/examples/app_vu/db_meter.py deleted file mode 100644 index 110b3cdf..00000000 --- a/examples/app_vu/db_meter.py +++ /dev/null @@ -1,132 +0,0 @@ -# Copyright 2017-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. - -# -*- coding: utf-8 -*- -import numpy as np -import matplotlib.pyplot as plt -from scipy import signal - -int32_max = np.int64(np.iinfo(np.int32).max) -int64_max = np.int64(np.iinfo(np.int64).max) - -f1 = 20.598997 -f2 = 107.65265 -f3 = 737.86223 -f4 = 12194.217 - -p1 = np.poly1d([1, 2.*np.pi*f1]) -p2 = np.poly1d([1, 2.*np.pi*f2]) -p3 = np.poly1d([1, 2.*np.pi*f3]) -p4 = np.poly1d([1, 2.*np.pi*f4]) - -def make_A_weighting(fs): - - p1_squared = np.polymul(p1, p1) - p4_squared = np.polymul(p4, p4) - - den = p1 - den = np.polymul(den, p1) - den = np.polymul(den, p4) - den = np.polymul(den, p4) - den = np.polymul(den, p2) - den = np.polymul(den, p3) - - num = np.poly1d([(2.*np.pi*f4)**2, 0, 0, 0, 0]) - - B, A = signal.bilinear(num, den, fs) - - return B, A - -def make_C_weighting(fs): - - den = p1 - den = np.polymul(den, p1) - den = np.polymul(den, p4) - den = np.polymul(den, p4) - num = np.poly1d([(2.*np.pi*f4)**2, 0, 0]) - - B, A = signal.bilinear(num, den, fs) - return B, A - -def output_filter(B, A, name, show_response = False, emit_test_ir = False, impulse_resp_length = 64): - - sos = signal.tf2sos(B, A) - - if show_response: - B, A = signal.sos2tf(sos) - w, h = signal.freqz(B, A, worN=2**12) - plt.title('Digital filter frequency response') - plt.semilogx(w*fs/(2.0*np.pi), 20 * np.log10(abs(h)), label = 'A_orig') - plt.ylim(-50, 20) - plt.ylabel('Amplitude [dB]', color='b') - plt.xlabel('Frequency [rad/sample]') - plt.grid() - plt.show() - - filter_q = 31 - max_q_adjust = 0 - for bq in range(len(sos)): - sos[bq] /= sos[bq][3] - abs_sum = sum(abs(sos[bq])) - 1.0 - m = int(np.ceil(np.log2(abs_sum))) #TODO check this works for -ve abs_sums - max_q_adjust = max(max_q_adjust, m) - - max_q_adjust -= 1 #to take advantage of 64 bit maccs - filter_q -= max_q_adjust - - #TODO check for -ve max_q_adjust - - sos_quantised = np.zeros(np.shape(sos)) - - int_max = np.int64(int32_max) / 2**max_q_adjust - print 'const int32_t filter_coeffs_' + name + '[] = {' - for bq in range(len(sos)): - print '\t', - for i in range(3): - v = np.int32(np.float64(int_max) * sos[bq][i]) - print str(v) + ', ' , - sos_quantised[bq][i] = np.float64(v) / np.float64(int_max) - for i in range(4, 6): - v = int(np.float64(int_max) * -sos[bq][i]) - sos_quantised[bq][i] = np.float64(-v) / np.float64(int_max) - print str(v) + ', ' , - print - sos_quantised[bq][3] = 1.0 - print '};' - print 'const uint32_t num_sections_' + name + ' = ' + str(len(sos)) + ';' - print 'const uint32_t q_format_' + name + ' = ' + str(filter_q) + ';' - print 'int32_t filter_state_'+ name +'[' +str(len(sos)) + '*DSP_NUM_STATES_PER_BIQUAD] = {0};' - d = np.zeros(impulse_resp_length) - d[0] = 1 - - B_q, A_q = signal.sos2tf(sos_quantised) - filter_impulse_response = signal.lfilter(B_q, A_q, d) - - if emit_test_ir: - print 'const unsigned impulse_resp_length_' + name + ' = ' + str(impulse_resp_length)+';' - print 'const int32_t expected_ir_' + name + '[' + str(impulse_resp_length) + '] = {' - for i in range(impulse_resp_length): - s = str(int(int32_max * filter_impulse_response[i])) + ', ' - if i%8 == 7: - print s - else: - print s, - print '};' - - return - -if __name__ == "__main__": - - fs = 48000 - - B_a, A_a = make_A_weighting(fs) - B_a *= (10.**(2.0/20.)) #to normalise 1kHz to 0dB - - B_c, A_c = make_C_weighting(fs) - B_c *= (10.**(0.06/20.)) #to normalise 1kHz to 0dB - - output_filter(B_a, A_a, 'A_weight') - output_filter(B_c, A_c, 'C_weight') - - - diff --git a/examples/app_vu/src/app_vu.xc b/examples/app_vu/src/app_vu.xc deleted file mode 100644 index c9519fda..00000000 --- a/examples/app_vu/src/app_vu.xc +++ /dev/null @@ -1,263 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include -#include - -#include -#include "mic_array.h" -#include "mic_array_board_support.h" -#include "dsp.h" - -#include "i2c.h" - -//If the decimation factor is changed the the coefs array of decimator_config must also be changed. -#define DECIMATION_FACTOR 2 //Corresponds to a 48kHz output sample rate -#define DECIMATOR_COUNT 2 //8 channels requires 2 decimators -#define FRAME_BUFFER_COUNT 2 //The minimum of 2 will suffice for this example - -on tile[1]:port p_i2c = XS1_PORT_4E; // Bit 0: SCLK, Bit 1: SDA - -on tile[0]:mabs_led_ports_t leds = MIC_BOARD_SUPPORT_LED_PORTS; -on tile[0]:in port p_buttons = MIC_BOARD_SUPPORT_BUTTON_PORTS; - -on tile[0]: out port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -const int32_t filter_coeffs_A_weight[] = { - 125794161, 251588322, 125794161, 120558903, -6768130, - 536870911, -1073882321, 537011429, 1016763977, -480585240, - 536870911, -1073601322, 536730429, 1070850480, -533983462, -}; -const uint32_t num_sections_A_weight = 3; -const uint32_t q_format_A_weight = 29; -int32_t filter_state_A_weight[3*DSP_NUM_STATES_PER_BIQUAD] = {0}; -const int32_t filter_coeffs_C_weight[] = { - 106216601, 212433202, 106216601, 120558903, -6768130, - 536870911, -1073741822, 536870911, 1070850480, -533983461, -}; -const uint32_t num_sections_C_weight = 2; -const uint32_t q_format_C_weight = 29; -int32_t filter_state_C_weight[2*DSP_NUM_STATES_PER_BIQUAD] = {0}; - -int data[8][THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR]; - -#include "log2_lut.h" - -q8_24 uint32_log2(uint32_t r){ - unsigned c = clz(r); - unsigned m = (r>>((32 - LOG2_BITS) - (c + 1)))&LOG2_MASK; - return -(int32_t)((c<<24) + log2_lut[m]); -} - -q8_24 uint64_log2(uint64_t r){ - unsigned c = clz(r>>32); - if(c == 32){ - unsigned more_c = clz(r&0xffffffff); - c+=more_c; - uint64_t t = (r>>((32 - LOG2_BITS) - (more_c + 1))); - unsigned m =t&LOG2_MASK; - return -(int32_t)((c<<24) + log2_lut[m]); - } else { - uint64_t t = (r>>((32 - LOG2_BITS) - (c + 1))); - unsigned m =(t>>32)&LOG2_MASK; - return -(int32_t)((c<<24) + log2_lut[m]); - } -} - -q8_24 log2_to_log10(const q8_24 i){ - const int32_t d = 1292913986; // (1.0/log2(10)) * (2^(31 + 1)-1) - return ((int64_t)d * (int64_t)i)>>(31+1); -} - -int64_t power(int32_t v){ - uint64_t p = (int64_t)v*(int64_t)v; - p<<=1; - return p; -} - -void update_power(uint64_t &lpf_p, uint32_t alpha, uint64_t p){ - - uint64_t lpf_p_top = lpf_p >> 32; - uint64_t lpf_p_bot = lpf_p&0xffffffff; - - uint64_t not_alpha = (uint64_t)(UINT_MAX - alpha); - - uint64_t l_top = lpf_p_top * not_alpha; - uint64_t l_bot = lpf_p_bot * not_alpha; - - uint64_t l = l_top + (l_bot>>32); - - uint64_t p_top = p >> 32; - uint64_t p_bot = p&0xffffffff; - - int64_t r_top = p_top *(int64_t)alpha; - int64_t r_bot = p_bot *(int64_t)alpha; - - uint64_t r = r_top + (r_bot>>32); - - lpf_p = l+r; -} - -/* - AKU441 - 116dbSPL = 0 dbFS = 2**32-1 linear power - 94dBSPL = -26dBFS = 10788470 linear power - 62dbSPL = -54dbFS = 6807 linear power - -89dbFS = 5 linear power (noise floor, a weighted) - - Brand x - 130dbSPL = 0 dbFS = 2**32-1 linear power - 94dBSPL = -36dBFS = 1078847 linear power - -105dbFS = 5 linear power (noise floor, a weighted) - -*/ -void vu(streaming chanend c_ds_output[DECIMATOR_COUNT], - client interface mabs_led_button_if lb, chanend c_printer) { - - unsafe{ - unsigned buffer; - memset(data, 0, sizeof(data)); - - mic_array_frame_time_domain audio[FRAME_BUFFER_COUNT]; - - mic_array_decimator_conf_common_t dcc = {0, 1, 0, 0, DECIMATION_FACTOR, - g_third_stage_div_2_fir, 0, FIR_COMPENSATOR_DIV_2, - DECIMATOR_NO_FRAME_OVERLAP, FRAME_BUFFER_COUNT}; - - mic_array_decimator_config_t dc[2] = { - {&dcc, data[0], {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0}, - {&dcc, data[4], {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0} - }; - - mic_array_decimator_configure(c_ds_output, DECIMATOR_COUNT, dc); - mic_array_init_time_domain_frame(c_ds_output, DECIMATOR_COUNT, buffer, audio, dc); - - unsigned selected_ch = 0; - - uint64_t pZ_slow = 0, pZ_fast = 0; - uint64_t pA_slow = 0, pA_fast = 0; - uint64_t pC_slow = 0, pC_fast = 0; - - //TODO give these exponential decay rates meaning. - uint32_t alpha_slow = (int64_t)((double)UINT_MAX * 0.01); - uint32_t alpha_fast = (int64_t)((double)UINT_MAX * 0.1); - - unsigned sample_rate = 48000; - unsigned counter = 0; - while(1){ - - mic_array_frame_time_domain * current = - mic_array_get_next_time_domain_frame(c_ds_output, DECIMATOR_COUNT, buffer, audio, dc); - - int32_t v = current->data[selected_ch][0]; - - v = v >> 1; // To ensure the gain of the A weighting never overflows, - // equlivant to -6.02dB. - - int32_t a = dsp_filters_biquads(v, filter_coeffs_A_weight, - filter_state_A_weight, num_sections_A_weight, q_format_A_weight); - int32_t c = dsp_filters_biquads(v, filter_coeffs_C_weight, - filter_state_C_weight, num_sections_C_weight, q_format_C_weight); - - uint64_t pV = power(v); - update_power(pZ_slow, alpha_slow, pV); - update_power(pZ_fast, alpha_fast, pV); - - uint64_t pA = power(a); - update_power(pA_slow, alpha_slow, pA); - update_power(pA_fast, alpha_fast, pA); - - uint64_t pC = power(c); - update_power(pC_slow, alpha_slow, pC); - update_power(pC_fast, alpha_fast, pC); - - q8_24 dB_pZ_slow = log2_to_log10(uint64_log2(pZ_slow)); - dB_pZ_slow = dB_pZ_slow*10 + Q24(6.02); //+6.02dB to undo the above - - q8_24 dB_pZ_fast = log2_to_log10(uint64_log2(pZ_fast)); - dB_pZ_fast = dB_pZ_fast*10 + Q24(6.02); - - q8_24 dB_pA_slow = log2_to_log10(uint64_log2(pA_slow)); - dB_pA_slow = dB_pA_slow*10 + Q24(6.02); - - q8_24 dB_pA_fast = log2_to_log10(uint64_log2(pA_fast)); - dB_pA_fast = dB_pA_fast*10 + Q24(6.02); - - q8_24 dB_pC_slow = log2_to_log10(uint64_log2(pC_slow)); - dB_pC_slow = dB_pC_slow*10 + Q24(6.02); - - q8_24 dB_pC_fast = log2_to_log10(uint64_log2(pC_fast)); - dB_pC_fast = dB_pC_fast*10 + Q24(6.02); - - if(counter == (sample_rate/16)){ - master{ - c_printer <: dB_pZ_slow; - c_printer <: dB_pZ_fast; - c_printer <: dB_pA_slow; - c_printer <: dB_pA_fast; - c_printer <: dB_pC_slow; - c_printer <: dB_pC_fast; - } - counter = 0; - } else { - counter++; - } - } - } -} - -void printer(chanend c_printer){ - q8_24 v[6]; - while(1){ - slave{ - for(unsigned i=0;i<6;i++){ - c_printer :> v[i]; - } - } - for(unsigned i=0;i<6;i++){ - printf("%f ", F24(v[i])); -// xscope_float(i, F24(v[i])); - } - printf("\n"); - } -} - -#define MASTER_TO_PDM_CLOCK_DIVIDER 4 - -int main() { - - i2c_master_if i_i2c[1]; - par { - - on tile[1]: [[distribute]]i2c_master_single_port(i_i2c, 1, p_i2c, 100, 0, 1, 0); - on tile[1]: { - mabs_init_pll(i_i2c[0], ETH_MIC_ARRAY); - } - on tile[0]: { - configure_clock_src_divide(pdmclk, p_mclk, MASTER_TO_PDM_CLOCK_DIVIDER); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - streaming chan c_4x_pdm_mic[DECIMATOR_COUNT]; - streaming chan c_ds_output[DECIMATOR_COUNT]; - - interface mabs_led_button_if lb[1]; - chan c_printer; - par { - mabs_button_and_led_server(lb, 1, leds, p_buttons); - mic_array_pdm_rx(p_pdm_mics, c_4x_pdm_mic[0], c_4x_pdm_mic[1]); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic[0], c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic[1], c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - vu(c_ds_output, lb[0], c_printer); - printer(c_printer); - } - } - } - return 0; -} diff --git a/examples/app_vu/src/log2_lut.h b/examples/app_vu/src/log2_lut.h deleted file mode 100644 index 4f29d6bc..00000000 --- a/examples/app_vu/src/log2_lut.h +++ /dev/null @@ -1,523 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef LOG2_LUT_H_ -#define LOG2_LUT_H_ - -#define LOG2_BITS 12 -#define LOG2_MASK ((1< - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/measure_phase_delay/.project b/legacy_tests/measure_phase_delay/.project deleted file mode 100644 index ded373fd..00000000 --- a/legacy_tests/measure_phase_delay/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - measure_phase_delay - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/measure_phase_delay/Makefile b/legacy_tests/measure_phase_delay/Makefile deleted file mode 100644 index 9fe8574b..00000000 --- a/legacy_tests/measure_phase_delay/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = measure_phase_delay - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_i2c lib_i2s lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/measure_phase_delay/config.xscope b/legacy_tests/measure_phase_delay/config.xscope deleted file mode 100644 index 48864698..00000000 --- a/legacy_tests/measure_phase_delay/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/measure_phase_delay/src/measure_phase_delay.xc b/legacy_tests/measure_phase_delay/src/measure_phase_delay.xc deleted file mode 100644 index 6cb6f764..00000000 --- a/legacy_tests/measure_phase_delay/src/measure_phase_delay.xc +++ /dev/null @@ -1,130 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "mic_array.h" - -#include "i2c.h" -#include "i2s.h" - -unsigned g_mem = 0; - -#define DF 12 //Decimation Factor - -on tile[0]: in port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -int data[4][THIRD_STAGE_COEFS_PER_STAGE*DF]; - -void test_output(streaming chanend c_ds_output[1]){ - unsafe{ - unsigned df[5] = {2, 4, 6, 8, 12}; - int comp [5] = { - FIR_COMPENSATOR_DIV_2, - FIR_COMPENSATOR_DIV_4, - FIR_COMPENSATOR_DIV_6, - FIR_COMPENSATOR_DIV_8, - FIR_COMPENSATOR_DIV_12, - }; - - int * unsafe coefs [5] = { - g_third_stage_div_2_fir, - g_third_stage_div_4_fir, - g_third_stage_div_6_fir, - g_third_stage_div_8_fir, - g_third_stage_div_12_fir, - }; - - mic_array_frame_time_domain audio[2]; - - unsigned buffer; //buffer index - memset(data, 0, sizeof(data)); - - for(unsigned index = 0; index < 5;index ++){ - unsigned max_count = 0; - - for(unsigned run = 0; run < 64;run ++){ - mic_array_decimator_conf_common_t dcc = {0, 0, 0, 0, df[index], - coefs[index], 0, comp[index], - DECIMATOR_NO_FRAME_OVERLAP, 2}; - mic_array_decimator_config_t dc[1] = {{&dcc, data[0], {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0}}; - - mic_array_decimator_configure(c_ds_output, 1, dc); - - mic_array_init_time_domain_frame(c_ds_output, 1, buffer, audio, dc); - - for(unsigned i=0;i<64;i++) - mic_array_get_next_time_domain_frame(c_ds_output, 1, buffer, audio, dc)->data[0][0]; - - asm volatile(""); - g_mem = 0xffffffff; - asm volatile(""); - unsigned count = 0; - int v =-1; - while(v<0){ - mic_array_frame_time_domain * current = mic_array_get_next_time_domain_frame(c_ds_output, 1, buffer, audio, dc); - v = current->data[0][0]; - count++; - } - asm volatile(""); - g_mem = 0; - asm volatile(""); - for(unsigned i=0;i<64;i++) - mic_array_get_next_time_domain_frame(c_ds_output, 1, buffer, audio, dc); - - if(count > max_count) - max_count = count; - - } - printf("%d Hz -> %3d samples phase delay\n", 96000/df[index], max_count); - } - } - _Exit(1); -} - - -extern void pdm_rx_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -int main(){ - - configure_clock_src_divide(pdmclk, p_mclk, 4); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - streaming chan c_4x_pdm_mic_0; - streaming chan c_ds_output[1]; - streaming chan not_a_port; - - par{ - - while(1){ - unsigned t; - unsafe { - p_pdm_mics :> int; //for synchronisation - asm volatile ("ldw %0, cp[g_mem]; out res[%1], %0": "=r"(t): "r"(not_a_port)); - - } - } - - pdm_rx_debug(not_a_port, c_4x_pdm_mic_0, null); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic_0, c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - test_output(c_ds_output); - par(int i=0;i<4;i++)while(1); - } - - return 0; -} diff --git a/legacy_tests/measure_phase_delay/src/mic_array_conf.h b/legacy_tests/measure_phase_delay/src/mic_array_conf.h deleted file mode 100644 index f95dfdfe..00000000 --- a/legacy_tests/measure_phase_delay/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 8 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/measure_phase_delay/wscript b/legacy_tests/measure_phase_delay/wscript deleted file mode 100644 index 67ea3486..00000000 --- a/legacy_tests/measure_phase_delay/wscript +++ /dev/null @@ -1,12 +0,0 @@ -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - bld.env.XCC_FLAGS = ['-O2', '-g'] - bld.env.TARGET_ARCH = 'XCORE-200-EXPLORER' - bld.env.XSCOPE = 'config.xscope' - bld.env.PROJECT_ROOT = '../../..' - - depends_on = ['lib_i2c', 'lib_i2s', 'lib_mic_array'] - prog = bld.program(depends_on=depends_on) diff --git a/legacy_tests/measure_size/.cproject b/legacy_tests/measure_size/.cproject deleted file mode 100644 index 87d17cf6..00000000 --- a/legacy_tests/measure_size/.cproject +++ /dev/null @@ -1,944 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/measure_size/.project b/legacy_tests/measure_size/.project deleted file mode 100644 index d1ec32cf..00000000 --- a/legacy_tests/measure_size/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - measure_size - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/measure_size/Makefile b/legacy_tests/measure_size/Makefile deleted file mode 100644 index 2ec7459a..00000000 --- a/legacy_tests/measure_size/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = measure_size - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g -report -Wno-timing - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/measure_size/config.xscope b/legacy_tests/measure_size/config.xscope deleted file mode 100644 index bfdf1f86..00000000 --- a/legacy_tests/measure_size/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/measure_size/src/measure_size.xc b/legacy_tests/measure_size/src/measure_size.xc deleted file mode 100644 index 71023c6c..00000000 --- a/legacy_tests/measure_size/src/measure_size.xc +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -dcc must match this. -#define DECIMATION_FACTOR 12 -#define DECIMATOR_COUNT 4 - -int data[DECIMATOR_COUNT][4*THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR]; - -void example(streaming chanend c_ds_output[DECIMATOR_COUNT]) { - unsafe{ - mic_array_frame_time_domain audio[DECIMATOR_COUNT]; //double buffered - - unsigned buffer; - - mic_array_decimator_conf_common_t dcc = { - 0, // Frame size log 2 is set to 0, i.e. one sample per channel will be present in each frame - 1, // DC offset elimination is turned on - 0, // Index bit reversal is off - 0, // No windowing function is being applied - DECIMATION_FACTOR,// The decimation factor is set to 6 - g_third_stage_div_2_fir, // This corresponds to a 16kHz output hence this coef array is used - 0, // Gain compensation is turned off - FIR_COMPENSATOR_DIV_2, // FIR compensation is set to the corresponding coefficients - DECIMATOR_NO_FRAME_OVERLAP, // Frame overlapping is turned off - 2 // There are 2 buffers in the audio array - }; - - mic_array_decimator_config_t dc[DECIMATOR_COUNT]; - - for(unsigned i=0;i - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/measure_tdh_plus_n/.project b/legacy_tests/measure_tdh_plus_n/.project deleted file mode 100644 index 042cf0ec..00000000 --- a/legacy_tests/measure_tdh_plus_n/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - measure_tdh_plus_n - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/measure_tdh_plus_n/DSD_sine1k0dBFsDSD_4M.dat b/legacy_tests/measure_tdh_plus_n/DSD_sine1k0dBFsDSD_4M.dat deleted file mode 100644 index 6aee3fd2..00000000 --- a/legacy_tests/measure_tdh_plus_n/DSD_sine1k0dBFsDSD_4M.dat +++ /dev/null @@ -1,4194307 +0,0 @@ -3072000.0 -1000.0 -3072000 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -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 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -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 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -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 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -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 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -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 -1 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -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 -1 -0 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 diff --git a/legacy_tests/measure_tdh_plus_n/DSD_zero_4M.dat b/legacy_tests/measure_tdh_plus_n/DSD_zero_4M.dat deleted file mode 100644 index a5c94fd6..00000000 --- a/legacy_tests/measure_tdh_plus_n/DSD_zero_4M.dat +++ /dev/null @@ -1,4194304 +0,0 @@ -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -0 -1 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -1 -0 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -0 -1 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -1 -0 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -1 -0 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -0 -1 -0 -1 -0 -1 -1 -0 -1 -0 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -0 -1 -1 -0 -0 -1 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -1 -0 -0 -1 -1 -0 -0 -1 -0 -1 -0 -1 -1 -0 -0 -1 -1 -0 diff --git a/legacy_tests/measure_tdh_plus_n/Makefile b/legacy_tests/measure_tdh_plus_n/Makefile deleted file mode 100644 index 11ed3121..00000000 --- a/legacy_tests/measure_tdh_plus_n/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = measure_tdh_plus_n - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O3 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -# The VERBOSE variable, if set to 1, enables verbose output from the make system. -VERBOSE = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/measure_tdh_plus_n/config.xscope b/legacy_tests/measure_tdh_plus_n/config.xscope deleted file mode 100644 index 9151872a..00000000 --- a/legacy_tests/measure_tdh_plus_n/config.xscope +++ /dev/null @@ -1,27 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/measure_tdh_plus_n/src/calc.py b/legacy_tests/measure_tdh_plus_n/src/calc.py deleted file mode 100644 index 233399a2..00000000 --- a/legacy_tests/measure_tdh_plus_n/src/calc.py +++ /dev/null @@ -1,111 +0,0 @@ -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -from __future__ import division -import sys -import re -from scipy.signal import blackmanharris -from numpy.fft import rfft, irfft -from numpy import argmax, sqrt, mean, absolute, arange, log10 -import numpy as np - -def rms_flat(a): - return sqrt(mean(absolute(a)**2)) - -def find_range(f, x): - """Find range between nearest local minima from peak at index x - - """ - - for i in arange(x+1, len(f)): - if f[i+1] >= f[i]: - uppermin = i - break - for i in arange(x-1, 0, -1): - if f[i] <= f[i-1]: - lowermin = i + 1 - break - return (lowermin, uppermin) - -def THDN(signal, sample_rate, filename): - - signal = signal - mean(signal) # this is so that the DC offset is not the peak in the case of PDM - windowed = signal * blackmanharris(len(signal)) - - - - # Find the peak of the frequency spectrum (fundamental frequency), and filter - # the signal by throwing away values between the nearest local minima - f = rfft(windowed) - - #limit the bandwidth - if len(f) > 24000: - f[24000:len(f)] = 0 - - bandwidth_limited = irfft(f) - total_rms = rms_flat(bandwidth_limited) - - #for i in range(6000): - #print abs(f[i]) - i = argmax(abs(f)) - - #This will be exact if the frequency under test falls into the middle of an fft bin - print 'Frequency: %f Hz' % (sample_rate * (i / len(windowed))) - lowermin, uppermin = find_range(abs(f), i) - - - #notch out the signal - f[lowermin: uppermin] = 0 - - - - noise = irfft(f) - THDN = rms_flat(noise) / total_rms - print "THD+N: %.12f%% or %.12f dB" % (THDN * 100, 20 * log10(THDN)) - -def load(filename): - signals = [] - line_number = [] - for c in range(16): - signal = [] - sample_rate= 0.0 - frequency_under_test = 0.0 - signals.append([signal, sample_rate, frequency_under_test]) - line_number.append(0) - - data_dropped = 0 - for line in open(filename,'r').readlines(): - if line.startswith("0: - print "data dropped " + str(data_dropped) - return signals - -files = sys.argv[1:] -if files: - for filename in files: - # try: - signals = load(filename) - - for s in signals: - if len(s[0])>0: - #verify that all the outputs happened - #print len(s[0]) - THDN(s[0], s[1], filename) - #except: - # print 'Couldn\'t analyze "' + filename + '"' - # print '' -else: - sys.exit("You must provide at least one file to analyze") diff --git a/legacy_tests/measure_tdh_plus_n/src/measure_tdh_plus_n.xc b/legacy_tests/measure_tdh_plus_n/src/measure_tdh_plus_n.xc deleted file mode 100644 index 6f4f737c..00000000 --- a/legacy_tests/measure_tdh_plus_n/src/measure_tdh_plus_n.xc +++ /dev/null @@ -1,239 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "mic_array.h" -#include -#include -#include -#include -#include - -//the frequency under test -#define TEST_FREQUENCY (1000.0) -#define SAMPLE_RATE (384000.0) -#define PDM_SAMPLE_RATE (3072000.0) - -#define SAMPLE_COUNT (384000) -#define PI (3.1415926535897932384626433832795028) -#define OMEGA (2.0*PI*TEST_FREQUENCY/SAMPLE_RATE) - -int data[4*THIRD_STAGE_COEFS_PER_STAGE*12] = {0}; - -#define OUTPUT_BACKEND_INPUT 0 -#define OUTPUT_BACKEND_OUTPUT 1 - -#define OUTPUT_FRONTEND_INPUT 0 -#define OUTPUT_FRONTEND_OUTPUT 0 - -extern void pdm_rx_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -void generate_backend_input(streaming chanend c_pdm_to_dec){ -#if OUTPUT_BACKEND_INPUT - xscope_int(3, SAMPLE_RATE); - xscope_int(3, TEST_FREQUENCY); -#endif - unsigned i=0; - for(i=0;idata[0][0]); -#endif - } - } - - delay_milliseconds(100); - _Exit(1); - } -} - - - -void create_DSD_source(streaming chanend c_not_a_port){ - - double sampleRate = 3072000.0; - double freq = 1000.0; - -#if OUTPUT_FRONTEND_INPUT - xscope_int(2, PDM_SAMPLE_RATE); - xscope_int(2, TEST_FREQUENCY); -#endif - - unsigned s=0; - - double c[] = { 0.79188240, 0.30454538, 0.06992965, 0.00949572, 0.00060680 }; - double g[] = { 0.000496, 0.001789 }; - - double s0 = 0; - double s1 = 0; - double s2 = 0; - double s3 = 0; - double s4 = 0; - - while(1){ - unsigned data = 0; - for(unsigned i=0;i<4;i++){ - double m = freq * 2.0 * PI / sampleRate; - double x = sin(s*m)*0.5; - double sum = c[0]*s0 + c[1]*s1 + c[2]*s2 + c[3]*s3 + c[4]*s4; - double y; - data = data>>8; - if (sum >= 0){ - y = 1.0; - data += 0xff000000; -#if OUTPUT_FRONTEND_INPUT - if (s < 3072000){ - delay_microseconds(240); - xscope_int(2, 1); - } -#endif - - } else { - y = -1.0; -#if OUTPUT_FRONTEND_INPUT - if (s < 3072000){ - delay_microseconds(240); - xscope_int(2, -1); - } -#endif - } - s4 = s4 + s3; - s3 = s3 + s2 - g[1]*s4; - s2 = s2 + s1; - s1 = s1 + s0 - g[0]*s2; - s0 = s0 + (x-y); - - s++; - } - c_not_a_port <: data; - } -} - -void get_frontend_output(streaming chanend c_4x_pdm_mic_0, - streaming chanend c_4x_pdm_mic_1){ - unsigned count = 3072000/8; -#if OUTPUT_FRONTEND_OUTPUT - xscope_int(1, count); - xscope_int(1, TEST_FREQUENCY); -#endif - for(unsigned i=0;i<64;i++){ - c_4x_pdm_mic_0 :> int; - c_4x_pdm_mic_1 :> int; - } - for(unsigned j=0;j a; - c_4x_pdm_mic_1 :> a; - } -#if OUTPUT_FRONTEND_OUTPUT - delay_microseconds(240); - xscope_int(1, a); -#endif - } -} - - -void test_frontend(){ - streaming chan c_not_a_port, c_4x_pdm_mic_0, c_4x_pdm_mic_1; - par { - create_DSD_source(c_not_a_port); - pdm_rx_debug(c_not_a_port, c_4x_pdm_mic_0, c_4x_pdm_mic_1); - get_frontend_output(c_4x_pdm_mic_0, c_4x_pdm_mic_1); - } -} - -void test_backend(){ - streaming chan c_pdm_to_dec; - streaming chan c_ds_output[1]; - par { - generate_backend_input(c_pdm_to_dec); - mic_array_decimate_to_pcm_4ch(c_pdm_to_dec, c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - get_backend_output(c_ds_output); - } -} - - -void test_all(){ - streaming chan c_ds_output[1]; - streaming chan c_not_a_port, c_4x_pdm_mic_0; - par { - create_DSD_source(c_not_a_port); - pdm_rx_debug(c_not_a_port, c_4x_pdm_mic_0, null); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic_0, c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - get_backend_output(c_ds_output); - } -} - - -int main(){ - xscope_int(0, 0); //to make xscope work - - test_all(); - /* - par { - test_frontend(); - test_backend(); - } - */ - return 0; -} diff --git a/legacy_tests/measure_tdh_plus_n/src/mic_array_conf.h b/legacy_tests/measure_tdh_plus_n/src/mic_array_conf.h deleted file mode 100644 index 27466508..00000000 --- a/legacy_tests/measure_tdh_plus_n/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 4 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/measure_tdh_plus_n/wscript b/legacy_tests/measure_tdh_plus_n/wscript deleted file mode 100644 index 9fee7101..00000000 --- a/legacy_tests/measure_tdh_plus_n/wscript +++ /dev/null @@ -1,12 +0,0 @@ -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - bld.env.XCC_FLAGS = ['-O3', '-g'] - bld.env.TARGET_ARCH = 'XCORE-200-EXPLORER' - bld.env.XSCOPE = 'config.xscope' - bld.env.PROJECT_ROOT = '../../..' - - depends_on = ['lib_mic_array'] - prog = bld.program(depends_on=depends_on) diff --git a/legacy_tests/pdm_interface.expect b/legacy_tests/pdm_interface.expect deleted file mode 100644 index f985b46a..00000000 --- a/legacy_tests/pdm_interface.expect +++ /dev/null @@ -1 +0,0 @@ -Success! diff --git a/legacy_tests/requirements.txt b/legacy_tests/requirements.txt deleted file mode 100644 index 61016be9..00000000 --- a/legacy_tests/requirements.txt +++ /dev/null @@ -1,5 +0,0 @@ -# python_version 2.7 - -numpy==1.16.6 -scipy==1.2.3 -soundfile==0.10.3.post1 diff --git a/legacy_tests/runtests.py b/legacy_tests/runtests.py deleted file mode 100755 index 8b98d9bf..00000000 --- a/legacy_tests/runtests.py +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/env python2.7 -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import xmostest - -if __name__ == "__main__": - xmostest.init() - - xmostest.register_group("lib_mic_array", - "lib_mic_array_frontend_tests", - "lib_mic_array frontend tests", - """ -Tests the lib_mic_array frontend, tests for: - * channel cross talk - * check for correct FIR coefficients on each channel -""") - - xmostest.register_group("lib_mic_array", - "lib_mic_array_backend_tests", - "lib_mic_array backend tests", - """ -Tests the lib_mic_array backend, tests for: - * 4, 8, 12, and 16 channels - * FIR compensation - * microphone gain compensation values - * microphone gain compensation enabled/disabled - * deciamtion factors: 2, 4, 6, 8 and 12 - * overlapping and non-overlapping frames - * windowing function application - * frame size log2 of 0, 1, 2, 3 and 4 - * index bit reversal enabled/disbaled - * XTA elimination on unlinked code -""") - - xmostest.register_group("lib_mic_array", - "lib_mic_array_channel_ordering_tests", - "lib_mic_array channel ordering tests", - """ -Tests the lib_mic_array channel ordering, tests for: - * check ``pdm_rx`` 4 and 8 channel orders - * check ``decimate_to_pcm_4ch`` maintains channel ordering -""") - - - xmostest.register_group("lib_mic_array", "mic_dual", "mic_dual", """Tests various aspects of the single threaded mic_dual component""") - - xmostest.runtests() - - xmostest.finish() diff --git a/legacy_tests/test_backend.py b/legacy_tests/test_backend.py deleted file mode 100644 index 3a865620..00000000 --- a/legacy_tests/test_backend.py +++ /dev/null @@ -1,39 +0,0 @@ -#!/usr/bin/env python -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import xmostest - -def do_backend_test(length, frame_count, testlevel): - - # Check if the test is running in an environment with hardware resources - # available - the test takes a long time to run in the simulator - args = xmostest.getargs() - if not args.remote_resourcer: - # Abort the test - print 'remote resourcer not avaliable' - return - - binary = 'test_fir_model/bin/COUNT{fc}_{len}/test_fir_model_COUNT{fc}_{len}.xe'.format(fc=frame_count, len=length) - - tester = xmostest.ComparisonTester(open('fir_model.expect'), - 'lib_mic_array', - 'lib_mic_array_backend_tests', - 'backend_test_%s'%testlevel, - {'frame_count':frame_count, 'length':length}) - - tester.set_min_testlevel(testlevel) - - resources = xmostest.request_resource("testrig_os_x_12", - tester) - - run_job = xmostest.run_on_xcore(resources['uac2_xcore200_mc_analysis_device_1'], - binary, - tester=tester, timeout=3600) - - xmostest.complete_all_jobs() - -def runtest(): - do_backend_test('LONG', 4, "smoke") - do_backend_test('SHORT', 4, "smoke") - do_backend_test('LONG', 64, "nightly") - do_backend_test('SHORT', 64, "nightly") diff --git a/legacy_tests/test_channel_ordering.py b/legacy_tests/test_channel_ordering.py deleted file mode 100644 index 0bf1e08c..00000000 --- a/legacy_tests/test_channel_ordering.py +++ /dev/null @@ -1,29 +0,0 @@ -#!/usr/bin/env python -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import xmostest - -def do_channel_ordering_test(test_name, testlevel): - - resources = xmostest.request_resource("xsim") - - binary = 'test_channel_ordering/bin/{t}/test_channel_ordering_{t}.xe'.format(t=test_name) - - tester = xmostest.ComparisonTester(open('test_channel_ordering_{t}.expect'.format(t=test_name)), - 'lib_mic_array', - 'lib_mic_array_channel_ordering_tests', - 'channel_ordering_test_%s'%testlevel, - {'config':test_name}) - - tester.set_min_testlevel(testlevel) - - xmostest.run_on_simulator(resources['xsim'], binary, - simargs=["--plugin", "LoopbackPort.dll", "-port tile[0] XS1_PORT_8A 8 0 -port tile[0] XS1_PORT_8B 8 0 "], - tester = tester) - -def runtest(): - do_channel_ordering_test("FRONTEND_8BIT_4CH", "smoke") - do_channel_ordering_test("FRONTEND_8BIT_8CH", "smoke") - do_channel_ordering_test("FRONTEND_8BIT_4CH_CHANREORDER", "smoke") - do_channel_ordering_test("FRONTEND_8BIT_8CH_CHANREORDER", "smoke") - do_channel_ordering_test("BACKEND", "smoke") diff --git a/legacy_tests/test_channel_ordering/.cproject b/legacy_tests/test_channel_ordering/.cproject deleted file mode 100644 index 3a7d0cb9..00000000 --- a/legacy_tests/test_channel_ordering/.cproject +++ /dev/null @@ -1,4234 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_channel_ordering/.project b/legacy_tests/test_channel_ordering/.project deleted file mode 100644 index 00068a7e..00000000 --- a/legacy_tests/test_channel_ordering/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_channel_ordering - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_channel_ordering/Makefile b/legacy_tests/test_channel_ordering/Makefile deleted file mode 100644 index 16a77f8e..00000000 --- a/legacy_tests/test_channel_ordering/Makefile +++ /dev/null @@ -1,34 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_channel_ordering - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -COMMON_FLAGS = -O2 -g -DTEST_MODE - - -# xmake doesn't like 'END' in a config name? -XCC_FLAGS_BACKEND = $(COMMON_FLAGS) -DBACKEND -XCC_FLAGS_FRONTEND_8BIT_4CH = $(COMMON_FLAGS) -DFRONTEND_8BIT_4CH -DTEST_MODE -XCC_FLAGS_FRONTEND_8BIT_8CH = $(COMMON_FLAGS) -DFRONTEND_8BIT_8CH -DTEST_MODE -XCC_FLAGS_FRONTEND_8BIT_4CH_CHANREORDER = $(COMMON_FLAGS) -DFRONTEND_8BIT_4CH -DTEST_MODE -DCHANNEL_REORDER_TEST -XCC_FLAGS_FRONTEND_8BIT_8CH_CHANREORDER = $(COMMON_FLAGS) -DFRONTEND_8BIT_8CH -DTEST_MODE -DCHANNEL_REORDER_TEST - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_channel_ordering/config.xscope b/legacy_tests/test_channel_ordering/config.xscope deleted file mode 100644 index 796cdf67..00000000 --- a/legacy_tests/test_channel_ordering/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_channel_ordering/src/mic_array_conf.h b/legacy_tests/test_channel_ordering/src/mic_array_conf.h deleted file mode 100644 index ccf51dcc..00000000 --- a/legacy_tests/test_channel_ordering/src/mic_array_conf.h +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 4 - -#ifdef CHANNEL_REORDER_TEST - #define MIC_ARRAY_CH0 PIN0 - #define MIC_ARRAY_CH1 PIN2 - #define MIC_ARRAY_CH2 PIN4 - #define MIC_ARRAY_CH3 PIN6 - #define MIC_ARRAY_CH4 PIN1 - #define MIC_ARRAY_CH5 PIN2 - #define MIC_ARRAY_CH6 PIN3 - #define MIC_ARRAY_CH7 PIN4 -#endif - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_channel_ordering/src/test_channel_ordering.xc b/legacy_tests/test_channel_ordering/src/test_channel_ordering.xc deleted file mode 100644 index 5eee5e60..00000000 --- a/legacy_tests/test_channel_ordering/src/test_channel_ordering.xc +++ /dev/null @@ -1,225 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "mic_array.h" -#include -#include -#include - -out port p_out = XS1_PORT_8A; - -in buffered port:32 p_pdm_mics = XS1_PORT_8B; -clock pdmclk = XS1_CLKBLK_1; - -void test8ch_frontend(){ - streaming chan c, d; - par { - { - configure_clock_ref(pdmclk, 10); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - mic_array_pdm_rx(p_pdm_mics, c, d); - } - { - p_out <: 0; - int initial = 0; - for(unsigned i=0;i<4;i++){ - c :> initial; - d :> initial; - } - for(unsigned ch=0;ch<8;ch++){ - p_out <: 1< new_vals[i]; - d :> new_vals[i+4]; - } - for(unsigned i=0;i<8;i++){ - if(vals[i] != new_vals[i]){ - changed = 1; - vals[i] = new_vals[i]; - } - } - if(!changed) - stable = 1; - - count++; - } - printf("Pin %d -> Channel ",ch); - //printf("*Channel %d -> Pin ",ch); - for(unsigned i=0;i<8;i++){ - int diff = vals[i]-initial; - if(diff) - printf("%d ", i); - } - printf("\n"); - } - _Exit(0); - } - } -} -void test4ch_frontend(){ - streaming chan c; - par { - { - configure_clock_ref(pdmclk, 10); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - mic_array_pdm_rx(p_pdm_mics, c, null); - } - { - p_out <: 0; - int initial = 0; - for(unsigned i=0;i<4;i++) - c :> initial; - - for(unsigned ch=0;ch<8;ch++){ - p_out <: 1< new_vals[i]; - } - for(unsigned i=0;i<4;i++){ - if(vals[i] != new_vals[i]){ - changed = 1; - vals[i] = new_vals[i]; - } - } - if(!changed) - stable = 1; - - count++; - } - printf("Pin %d -> Channel ",ch); - //printf("Channel %d -> Pin ",ch); - for(unsigned i=0;i<4;i++){ - int diff = vals[i]-initial; - if(diff) - printf("%d ", i); - } - printf("\n"); - } - _Exit(0); - } - } -} - -int data[4*THIRD_STAGE_COEFS_PER_STAGE*2] = {0}; -void test4ch_backend(){ - - streaming chan c_pdm_to_dec; - streaming chan c_ds_output[1]; - par { - { - unsigned N = 48*8; - c_pdm_to_dec <: 0x7fffffff; - c_pdm_to_dec <: 0; - c_pdm_to_dec <: 0; - c_pdm_to_dec <: 0; - - for(unsigned i=0;idata[i][0] ==0); - if(current->data[i][0] != 0){ - if(active_channel >= 0){ - printf("Error: two channels active at the same time\n"); - _Exit(1); - } else { - active_channel = i; - } - } - } - - if(!all_zero){ - if(active_channel != last_seen){ - printf("channel: %d\n", active_channel); - last_seen = active_channel; - } - } - } - } - } - } - -} - -int main(){ - -#ifdef FRONTEND_8BIT_4CH - test4ch_frontend(); -#endif - -#ifdef FRONTEND_8BIT_8CH - test8ch_frontend(); -#endif - -#ifdef BACKEND - test4ch_backend(); -#endif - return 0; -} diff --git a/legacy_tests/test_channel_ordering/wscript b/legacy_tests/test_channel_ordering/wscript deleted file mode 100644 index fbb282d6..00000000 --- a/legacy_tests/test_channel_ordering/wscript +++ /dev/null @@ -1,76 +0,0 @@ -import os -from waflib import Options, Errors -from waflib.Build import BuildContext, CleanContext - -CONFIGS = [ - 'FRONTEND_8BIT_4CH', - 'FRONTEND_8BIT_8CH', - 'FRONTEND_8BIT_4CH_CHANREORDER', - 'BACKEND', - 'FRONTEND_8BIT_8CH_CHANREORDER' -] - -def create_waf_contexts(configs): - for test_name in configs: - for ctx in (BuildContext, CleanContext): - raw_context = ctx.__name__.replace('Context', '').lower() - - class tmp(ctx): - cmd = raw_context + '_' + test_name - variant = test_name - variant = os.path.split(os.getcwd())[1] + '_' + variant - -create_waf_contexts(CONFIGS) - -def options(opt): - opt.load('xwaf.xcommon') - - -def configure(conf): - opt.add_option('--config', action='store', - help='Choose among the supported configurations') - conf.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - - if not bld.variant: - build_configs = [] - try: - build_configs = [ - c for c in CONFIGS if c == bld.options.config.upper() - ] - except AttributeError: - pass - - if len(build_configs) == 0: - bld.fatal('specify a config with --config.\nAvailable configs: {}'.format(', '.join(CONFIGS))) - return - - build_commands = ['{}_{}'.format(bld.cmd, c) for c in build_configs] - print("build_commands = {}".format(build_commands)) - - if not build_commands: - bld.fatal/( - '{} does not match any configs'.format(bld.options.config)) - - cmd_str = {'build': 'Building', 'clean': 'Cleaning', 'list': "Listing"}[bld.cmd] - print('{} configs:\n {}'.format(cmd_str, '\n '.join( - build_configs))) - if not bld.cmd == 'list': - Options.commands = build_commands + Options.commands - return - - bld.do_xcommon() - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/legacy_tests/test_channel_ordering_BACKEND.expect b/legacy_tests/test_channel_ordering_BACKEND.expect deleted file mode 100644 index 798a6795..00000000 --- a/legacy_tests/test_channel_ordering_BACKEND.expect +++ /dev/null @@ -1,5 +0,0 @@ -channel: 0 -channel: 1 -channel: 2 -channel: 3 - diff --git a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_4CH.expect b/legacy_tests/test_channel_ordering_FRONTEND_8BIT_4CH.expect deleted file mode 100644 index 9d5ee56b..00000000 --- a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_4CH.expect +++ /dev/null @@ -1,9 +0,0 @@ -Pin 0 -> Channel 0 -Pin 1 -> Channel 1 -Pin 2 -> Channel 2 -Pin 3 -> Channel 3 -Pin 4 -> Channel -Pin 5 -> Channel -Pin 6 -> Channel -Pin 7 -> Channel - diff --git a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_4CH_CHANREORDER.expect b/legacy_tests/test_channel_ordering_FRONTEND_8BIT_4CH_CHANREORDER.expect deleted file mode 100644 index 22f028a5..00000000 --- a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_4CH_CHANREORDER.expect +++ /dev/null @@ -1,9 +0,0 @@ -Pin 0 -> Channel 0 -Pin 1 -> Channel -Pin 2 -> Channel 1 -Pin 3 -> Channel -Pin 4 -> Channel 2 -Pin 5 -> Channel -Pin 6 -> Channel 3 -Pin 7 -> Channel - diff --git a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_8CH.expect b/legacy_tests/test_channel_ordering_FRONTEND_8BIT_8CH.expect deleted file mode 100644 index f867f0aa..00000000 --- a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_8CH.expect +++ /dev/null @@ -1,9 +0,0 @@ -Pin 0 -> Channel 0 -Pin 1 -> Channel 1 -Pin 2 -> Channel 2 -Pin 3 -> Channel 3 -Pin 4 -> Channel 4 -Pin 5 -> Channel 5 -Pin 6 -> Channel 6 -Pin 7 -> Channel 7 - diff --git a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_8CH_CHANREORDER.expect b/legacy_tests/test_channel_ordering_FRONTEND_8BIT_8CH_CHANREORDER.expect deleted file mode 100644 index 19ebabec..00000000 --- a/legacy_tests/test_channel_ordering_FRONTEND_8BIT_8CH_CHANREORDER.expect +++ /dev/null @@ -1,9 +0,0 @@ -Pin 0 -> Channel 0 -Pin 1 -> Channel 4 -Pin 2 -> Channel 1 5 -Pin 3 -> Channel 6 -Pin 4 -> Channel 2 7 -Pin 5 -> Channel -Pin 6 -> Channel 3 -Pin 7 -> Channel - diff --git a/legacy_tests/test_dc_offset_removal.expect b/legacy_tests/test_dc_offset_removal.expect deleted file mode 100644 index f985b46a..00000000 --- a/legacy_tests/test_dc_offset_removal.expect +++ /dev/null @@ -1 +0,0 @@ -Success! diff --git a/legacy_tests/test_dc_offset_removal.py b/legacy_tests/test_dc_offset_removal.py deleted file mode 100644 index 7c809505..00000000 --- a/legacy_tests/test_dc_offset_removal.py +++ /dev/null @@ -1,35 +0,0 @@ -#!/usr/bin/env python -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import xmostest - -def do_dc_offset_removal_test(testlevel): - - # Check if the test is running in an environment with hardware resources - # available - the test takes a long time to run in the simulator - args = xmostest.getargs() - if not args.remote_resourcer: - # Abort the test - print 'remote resourcer not avaliable' - return - - binary = 'test_dc_offset_removal/bin/test_dc_offset_removal.xe' - - tester = xmostest.ComparisonTester(open('test_dc_offset_removal.expect'), - 'lib_mic_array', - 'lib_mic_array_backend_tests', - 'dc_offset_removal_test_%s'%testlevel) - - tester.set_min_testlevel(testlevel) - - resources = xmostest.request_resource("testrig_os_x_12", - tester) - - run_job = xmostest.run_on_xcore(resources['uac2_xcore200_mc_analysis_device_1'], - binary, - tester=tester) - - xmostest.complete_all_jobs() - -def runtest(): - do_dc_offset_removal_test("smoke") diff --git a/legacy_tests/test_dc_offset_removal/.cproject b/legacy_tests/test_dc_offset_removal/.cproject deleted file mode 100644 index 4c05c6c7..00000000 --- a/legacy_tests/test_dc_offset_removal/.cproject +++ /dev/null @@ -1,944 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - diff --git a/legacy_tests/test_dc_offset_removal/.project b/legacy_tests/test_dc_offset_removal/.project deleted file mode 100644 index 04d41259..00000000 --- a/legacy_tests/test_dc_offset_removal/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_dc_offset_removal - - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_dc_offset_removal/Makefile b/legacy_tests/test_dc_offset_removal/Makefile deleted file mode 100644 index e53cb85b..00000000 --- a/legacy_tests/test_dc_offset_removal/Makefile +++ /dev/null @@ -1,26 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_dc_offset_removal - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_dc_offset_removal/config.xscope b/legacy_tests/test_dc_offset_removal/config.xscope deleted file mode 100644 index 47351f2f..00000000 --- a/legacy_tests/test_dc_offset_removal/config.xscope +++ /dev/null @@ -1,19 +0,0 @@ - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_dc_offset_removal/src/mic_array_conf.h b/legacy_tests/test_dc_offset_removal/src/mic_array_conf.h deleted file mode 100644 index 27466508..00000000 --- a/legacy_tests/test_dc_offset_removal/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 4 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_dc_offset_removal/src/test_dc_offset_removal.xc b/legacy_tests/test_dc_offset_removal/src/test_dc_offset_removal.xc deleted file mode 100644 index be9d5067..00000000 --- a/legacy_tests/test_dc_offset_removal/src/test_dc_offset_removal.xc +++ /dev/null @@ -1,117 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "mic_array.h" -#include -#include -#include -#include -#include -#include - -int data[4*THIRD_STAGE_COEFS_PER_STAGE*2] = {0}; - -int dc_elim_model(int32_t x, int32_t &prev_x, int64_t & y){ -#define S 0 -#define N 8 - int64_t X = x; - int64_t prev_X = prev_x; - - y = y - (y>>8); - - prev_X<<=32; - y = y - prev_X; - - X<<=32; - y = y + X; - - prev_x = x; - return (y>>(32-S)); -} -#define DC_OFFSET 0xf123456 -void test(){ - - streaming chan c_pdm_to_dec; - streaming chan c_ds_output[1]; - par { - { -#define SINE_LENGTH 64 -#define INPUT_SAMPLES (SINE_LENGTH*8) - - int one_khz_sine[INPUT_SAMPLES]; - int actual_dc_offset = DC_OFFSET; - - for(unsigned i=0;idata[0][0]; - - //wait for DC to become zero - sum -= rolling_window[head]; - sum += x; - rolling_window[head] = x; - head ++; - if(head == SINE_LENGTH) - head = 0; - - int diff = x - prev_x; - if (diff < 0) diff = -diff; - if(diff > (INT_MAX/2)){ - printf("Error: sine wrapped really hard\n"); - _Exit(1); - } - prev_x=x; - - int32_t abs_sum = sum; - if(abs_sum < 0) - abs_sum = -abs_sum; - - if((count > 30)&&(abs_sum < (SINE_LENGTH*2))){ - printf("Success!\n"); - _Exit(1); - } - - } - } - } - } - -} - -int main(){ - - test(); - return 0; -} diff --git a/legacy_tests/test_dc_offset_removal/wscript b/legacy_tests/test_dc_offset_removal/wscript deleted file mode 100644 index 503f2d4f..00000000 --- a/legacy_tests/test_dc_offset_removal/wscript +++ /dev/null @@ -1,22 +0,0 @@ -def options(opt): - opt.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - bld.do_xcommon() - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/legacy_tests/test_fir_model/.cproject b/legacy_tests/test_fir_model/.cproject deleted file mode 100644 index 2556deed..00000000 --- a/legacy_tests/test_fir_model/.cproject +++ /dev/null @@ -1,3553 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_fir_model/.project b/legacy_tests/test_fir_model/.project deleted file mode 100644 index 04c3f7c3..00000000 --- a/legacy_tests/test_fir_model/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_fir_model - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_fir_model/Makefile b/legacy_tests/test_fir_model/Makefile deleted file mode 100644 index c163b8fa..00000000 --- a/legacy_tests/test_fir_model/Makefile +++ /dev/null @@ -1,32 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_fir_model - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_logging lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -COMMON_FLAGS = -O2 -g -DDEBUG_PRINT_ENABLE=1 -report -Wno-timing - -XCC_FLAGS_COUNT4_LONG = $(COMMON_FLAGS) -DCOUNT=4 -DMIC_ARRAY_WORD_LENGTH_SHORT=0 -XCC_FLAGS_COUNT64_LONG = $(COMMON_FLAGS) -DCOUNT=64 -DMIC_ARRAY_WORD_LENGTH_SHORT=0 -XCC_FLAGS_COUNT4_SHORT = $(COMMON_FLAGS) -DCOUNT=4 -DMIC_ARRAY_WORD_LENGTH_SHORT=1 -XCC_FLAGS_COUNT64_SHORT = $(COMMON_FLAGS) -DCOUNT=64 -DMIC_ARRAY_WORD_LENGTH_SHORT=1 - - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_fir_model/XCORE-200-EXPLORER.xn b/legacy_tests/test_fir_model/XCORE-200-EXPLORER.xn deleted file mode 100644 index 7a45a6c2..00000000 --- a/legacy_tests/test_fir_model/XCORE-200-EXPLORER.xn +++ /dev/null @@ -1,59 +0,0 @@ - - - Board - xCORE-200 Explorer Kit - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_fir_model/config.xscope b/legacy_tests/test_fir_model/config.xscope deleted file mode 100644 index 796cdf67..00000000 --- a/legacy_tests/test_fir_model/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_fir_model/src/mic_array_conf.h b/legacy_tests/test_fir_model/src/mic_array_conf.h deleted file mode 100644 index b98cf06d..00000000 --- a/legacy_tests/test_fir_model/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 4 -#define MIC_ARRAY_NUM_MICS 16 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_fir_model/src/test_fir_model.xc b/legacy_tests/test_fir_model/src/test_fir_model.xc deleted file mode 100644 index a9b2825b..00000000 --- a/legacy_tests/test_fir_model/src/test_fir_model.xc +++ /dev/null @@ -1,697 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include "mic_array.h" -#include -#include -#include -#include -#include "debug_print.h" -#include - -#define DF 12 //12 is the maximum I want to support -#define FRAME_COUNT 3 - -static int pseudo_random(unsigned &x){ - crc32(x, -1, 0xEB31D82E); - return (int)x; -} - -#pragma unsafe arrays -static unsafe void add_to_filter(int * unsafe data, const unsigned length, - const int val, unsigned &n){ - data[n] = val; - if ((n + 1) == length) - n=0; - else - n=n+1; -} - -#pragma unsafe arrays -static unsafe int filter(const int * unsafe coefs, int * unsafe data, const unsigned length, - const int val, unsigned &n){ - - long long y = 0; - data[n] = val; - for (unsigned i=0; i>31; -} - -#pragma unsafe arrays -int generate_tail_output_counter(unsigned fsl2, unsigned df, mic_array_decimator_buffering_t buf_type){ - if(buf_type == DECIMATOR_NO_FRAME_OVERLAP){ - if(fsl2==0) - return 0; - unsigned v=df*4; - for(unsigned i=1;i>27; - } else { - v = (long long)val; - } - return (int)v; -} - -static int apply_gain_comp(int val, int gain){ - long long v = (long long)val; - v = v * (long long)gain; - v=v>>31; - return (int)v; -} - -static unsigned bitreverse(unsigned i, unsigned bits){ - return (bitrev(i) >> (32-bits)); -} - -#pragma unsafe arrays -void model(streaming chanend c_4x_pdm_mic[4], unsigned channel_count, chanend c_model){ - int second_stage_data[16][16]; - int third_stage_data[16][32*DF]; - - unsigned second_stage_n[16] = {0}; - unsigned third_stage_n[16] = {0}; - - int window[1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2-1)]; - { - unsigned x=0x9876543; - for(unsigned i=0;i<(1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2-1)); i++) - window[i] = pseudo_random(x); - } - - unsigned x=0x1234; - unsafe { - while(1){ - - c_model :> int; - c_model <: 0; - int r; - c_model :> r; - if(r) - return; - - int * unsafe fir; - int * unsafe debug_fir; - unsigned df; - int fir_comp; - unsigned frame_size_log2; - unsigned index_bit_reversal; - unsigned gain_comp_enabled; - unsigned gain_comp[16]; - unsigned windowing_enabled; - mic_array_decimator_buffering_t buf_type; - slave{ - c_model :> fir; - c_model :> debug_fir; - c_model :> df; - c_model :> fir_comp; - c_model :> frame_size_log2; - c_model :> index_bit_reversal; - c_model :> gain_comp_enabled; - for(unsigned i=0;i<16;i++) - c_model:> gain_comp[i]; - c_model :> windowing_enabled; - c_model :> buf_type; - } - int output[16][COUNT<>(frame_size_log2-1))) - index += (1<<(frame_size_log2-1)); - - if(index>>(frame_size_log2-1)) - index = (1<>(frame_size_log2-1)) - index = (1<>16); -#else - printf("%08x ", output[m][c]); -#endif -#endif - } -#if DEBUG_MODEL - printf("\n"); -#endif - } - } - } -} - -#pragma unsafe arrays -void output(streaming chanend c_ds_output[4], chanend c_actual, unsigned channel_count){ - - mic_array_frame_time_domain audio[FRAME_COUNT]; - mic_array_frame_fft_preprocessed f_complex[FRAME_COUNT]; - - //FIXME this might cause weird crashes!! due to memory alignment - int data_0[4*THIRD_STAGE_COEFS_PER_STAGE*DF] = {0}; - int data_1[4*THIRD_STAGE_COEFS_PER_STAGE*DF] = {0}; - int data_2[4*THIRD_STAGE_COEFS_PER_STAGE*DF] = {0}; - int data_3[4*THIRD_STAGE_COEFS_PER_STAGE*DF] = {0}; - - int window[1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2-1)]; - { - unsigned x=0x9876543; - for(unsigned i=0;i<(1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2-1)); i++) - window[i] = pseudo_random(x); - } - - unsafe { - - while(1){ - //get the settings from the verifier - - c_actual :> int; - c_actual <: 0; - int r; - c_actual :> r; - if(r) - return; - - int * unsafe fir; - int * unsafe debug_fir; - unsigned df; - int fir_comp; - unsigned frame_size_log2; - unsigned index_bit_reversal; - unsigned gain_comp_enabled; - unsigned gain_comp[16]; - unsigned windowing_enabled; - mic_array_decimator_buffering_t buf_type; - slave{ - c_actual :> fir; - c_actual :> debug_fir; - c_actual :> df; - c_actual :> fir_comp; - c_actual :> frame_size_log2; - c_actual :> index_bit_reversal; - c_actual :> gain_comp_enabled; - for(unsigned i=0;i<16;i++) - c_actual:> gain_comp[i]; - c_actual :> windowing_enabled; - c_actual :> buf_type; - } - unsigned buffer; - - int output[16][COUNT<metadata[md].frame_number != frame_number){ - printf("error 1: got frame %d expected %d\n", current->metadata[md].frame_number, frame_number); - } - } - frame_number++; - - for(unsigned f=0;f<(1<data[m][f].re; - output[2*m+1][index] = current->data[m][f].im; - } - } - } - } else { - for(unsigned c=0;c<2*COUNT;c++){ - mic_array_frame_fft_preprocessed * current = mic_array_get_next_frequency_domain_frame(c_ds_output, channel_count/4, buffer, f_complex, dc); - - - for(unsigned md=0;md < channel_count/4;md++){ - if(current->metadata[md].frame_number != frame_number){ - printf("error 2: got frame %d expected %d\n", current->metadata[md].frame_number, frame_number); - } - } - frame_number++; - - - if(c > 0){ - for(unsigned f=0;f<(1<<(frame_size_log2-1));f++){ - for(unsigned m=0;mdata[m][f].re; - //output[2*m+1][index] = current->data[m][f].im; - } - } - } - for(unsigned f=(1<<(frame_size_log2-1));f<(1<data[m][ff].re; - output[2*m+1][index] = current->data[m][ff].im; - } - } - - } - } - } else { - mic_array_decimator_conf_common_t dcc = { - frame_size_log2, 0, index_bit_reversal, 0, df, fir, gain_comp_enabled, fir_comp, buf_type, FRAME_COUNT}; - - if(windowing_enabled) - dcc.windowing_function = window; - - mic_array_decimator_config_t dc[4] = { - {&dcc, data_0, {gain_comp[0], gain_comp[1], gain_comp[2], gain_comp[3]}, 4, 0}, - {&dcc, data_1, {gain_comp[4], gain_comp[5], gain_comp[6], gain_comp[7]}, 4, 0}, - {&dcc, data_2, {gain_comp[8], gain_comp[9], gain_comp[10], gain_comp[11]}, 4, 0}, - {&dcc, data_3, {gain_comp[12], gain_comp[13], gain_comp[14], gain_comp[15]}, 4, 0} - }; - mic_array_decimator_configure(c_ds_output, channel_count/4, dc); - - mic_array_init_time_domain_frame(c_ds_output, channel_count/4, buffer, audio, dc); - - if(buf_type==DECIMATOR_NO_FRAME_OVERLAP){ - for(unsigned c=0;cmetadata[md].frame_number != frame_number){ - printf("error 3: got frame %d expected %d\n", current->metadata[md].frame_number, frame_number); - } - } - frame_number++; - - for(unsigned f=0;f<(1<data[m][f]; - } - } - } - } else { - for(unsigned c=0;c<2*COUNT;c++){ - mic_array_frame_time_domain * current = mic_array_get_next_time_domain_frame(c_ds_output, channel_count/4, buffer, audio, dc); - - - for(unsigned md=0;md < channel_count/4;md++){ - if(current->metadata[md].frame_number != frame_number){ - printf("error 4: got frame %d expected %d\n", current->metadata[md].frame_number, frame_number); - } - } - frame_number++; - - if(c > 0){ - for(unsigned f=0;f<(1<<(frame_size_log2-1));f++){ - unsigned index = (c<<(frame_size_log2-1)) + f - (1<<(frame_size_log2-1)); - for(unsigned m=0;mdata[m][f]; - } - } - } - for(unsigned f=(1<<(frame_size_log2-1));f<(1<data[m][f]; - } - } - } - } - } - - for(unsigned c=0;c>16); -#else - printf("%08x ", output[m][c]); -#endif -#endif - } -#if DEBUG_OUTPUT - printf("\n"); -#endif - } - } - } -} - -#pragma unsafe arrays -static void send_settings(chanend c_chan, - const int * unsafe fir, const int * unsafe debug_fir, unsigned df, int fir_comp, - unsigned frame_size_log2, unsigned index_bit_reversal, unsigned gain_comp_enabled, - unsigned gain[16], unsigned windowing_enabled, - mic_array_decimator_buffering_t buf_type){ - unsafe{ - master { - c_chan <: fir; - c_chan <: debug_fir; - c_chan <: df; - c_chan <: fir_comp; - c_chan <: frame_size_log2; - c_chan <: index_bit_reversal; - c_chan <: gain_comp_enabled; - for(unsigned i=0;i<16;i++) - c_chan <: gain[i]; - c_chan <: windowing_enabled; - c_chan <: buf_type; - } - - } -} - -#pragma unsafe arrays -void verifier(chanend c_model, chanend c_actual, unsigned channel_count){ - unsafe{ - unsigned decimation_factor_lut[5] = {1*2, 2*2, 3*2, 4*2, 6*2}; - - const int * unsafe decimation_fir_lut[5] = { - g_third_stage_div_2_fir, - g_third_stage_div_4_fir, - g_third_stage_div_6_fir, - g_third_stage_div_8_fir, - g_third_stage_div_12_fir, - }; - const int * unsafe decimation_fir_debug_lut[5] = { - fir3_div_2_debug, - fir3_div_4_debug, - fir3_div_6_debug, - fir3_div_8_debug, - fir3_div_12_debug, - }; - - unsigned fir_comp_lut[4] = {0, INT_MAX>>4, INT_MAX<<4, INT_MAX>>8}; - - unsigned gain_comp[2][16] = { { INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, - INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, - INT_MAX, INT_MAX }, { INT_MAX / 2, INT_MAX / 3, INT_MAX / 4, INT_MAX / 6, - INT_MAX / 7, INT_MAX / 8, INT_MAX / 9, INT_MAX / 11, - INT_MAX / 12, INT_MAX / 13, INT_MAX / 14, INT_MAX / 16, INT_MAX / 17, INT_MAX - / 18, INT_MAX / 19, INT_MAX / 111, } }; - - unsigned test = 0; - - for(unsigned frame_size_log2 = 0;frame_size_log2<=MIC_ARRAY_MAX_FRAME_SIZE_LOG2;frame_size_log2++){ - - for(unsigned decimation_index = 0; decimation_index < 5;decimation_index++){ - const int * unsafe fir = decimation_fir_lut[decimation_index]; - const int * unsafe debug_fir = decimation_fir_debug_lut[decimation_index]; - unsigned df = decimation_factor_lut[decimation_index]; - - for(unsigned fir_comp_index=0; fir_comp_index<4;fir_comp_index++){ - int fir_comp = fir_comp_lut[fir_comp_index]; - - for(unsigned index_bit_reversal=0;index_bit_reversal<2;index_bit_reversal++){ - - for(unsigned gain_comp_enabled = 0; gain_comp_enabled<2;gain_comp_enabled++){ - - for(unsigned gain_index=0;gain_index<2;gain_index++){ - - for(unsigned windowing_enabled=0;windowing_enabled<2; windowing_enabled++){ - - for(mic_array_decimator_buffering_t buf_type = 0; buf_type<2; buf_type++){ - if((frame_size_log2 == 0) && (buf_type == DECIMATOR_HALF_FRAME_OVERLAP)) - continue; - - c_actual <: 0; - c_model <: 0; - c_actual:> int; - c_model :> int; - c_actual <: 0; - c_model <: 0; - - send_settings(c_model, fir, debug_fir, df, fir_comp, - frame_size_log2, index_bit_reversal, gain_comp_enabled, - gain_comp[gain_index], windowing_enabled, buf_type); - send_settings(c_actual, fir, debug_fir, df, fir_comp, - frame_size_log2, index_bit_reversal, gain_comp_enabled, - gain_comp[gain_index], windowing_enabled, buf_type); - - int max_diff = 0; - for(unsigned m=0;m a; - c_model :> b; - // printf("%d %d\n", a, b); -#if MIC_ARRAY_WORD_LENGTH_SHORT - b = b >>16; -#endif - - int diff = a-b; - if (diff<0) diff = -diff; - if(diff>max_diff) - max_diff = diff; - } - } - - if(max_diff < 16){ - test++; - } else{ - printf("%4d ", test++); - printf("df: %2d ", df); - printf("fir_comp: 0x%08x ", fir_comp); - printf("frame_size_log2: %d ", frame_size_log2); - printf("index_bit_reversal: %d ", index_bit_reversal); - printf("windowing_enabled: %d ", windowing_enabled); - printf("gain_comp_enabled: %d ", gain_comp_enabled); - printf("mic_array_decimator_buffering_t: %d ", buf_type); - printf(" FAIL\n"); - delay_milliseconds(50); - _Exit(1); - - } - } - } - } - } - } - } - } - } - } - - c_actual <: 0; - c_model <: 0; - c_actual:> int; - c_model :> int; - c_actual <: 1; - c_model <: 1; - - debug_printf("Success: %d channels supported\n", channel_count); -} - -void channel_count_test(unsigned counts[], unsigned n){ - streaming chan c_4x_pdm_mic[4]; - streaming chan c_ds_output[4]; - chan c_model, c_actual; - par { - { - for(unsigned c=0; c - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_frame_drop/.project b/legacy_tests/test_frame_drop/.project deleted file mode 100644 index 7af676e2..00000000 --- a/legacy_tests/test_frame_drop/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_frame_drop - - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_frame_drop/Makefile b/legacy_tests/test_frame_drop/Makefile deleted file mode 100644 index d7656355..00000000 --- a/legacy_tests/test_frame_drop/Makefile +++ /dev/null @@ -1,26 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_frame_drop - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array lib_xassert - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g -DDEBUG_MIC_ARRAY - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_frame_drop/config.xscope b/legacy_tests/test_frame_drop/config.xscope deleted file mode 100644 index bfdf1f86..00000000 --- a/legacy_tests/test_frame_drop/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_frame_drop/src/mic_array_conf.h b/legacy_tests/test_frame_drop/src/mic_array_conf.h deleted file mode 100644 index 67dde803..00000000 --- a/legacy_tests/test_frame_drop/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 3 -#define MIC_ARRAY_NUM_MICS 8 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_frame_drop/src/test_frame_drop.xc b/legacy_tests/test_frame_drop/src/test_frame_drop.xc deleted file mode 100644 index 4fa62dd5..00000000 --- a/legacy_tests/test_frame_drop/src/test_frame_drop.xc +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include -#include "mic_array.h" - -#define DF 2 //Decimation Factor - -int data[8][4*THIRD_STAGE_COEFS_PER_STAGE*DF]; - -void test_output(streaming chanend c_ds_output[2]){ - - memset(data, 0, sizeof(data)); - mic_array_frame_time_domain audio[2]; - - unsafe{ - unsigned buffer; //buffer index - memset(audio, sizeof(mic_array_frame_time_domain), 0); - - mic_array_decimator_conf_common_t dcc = {MIC_ARRAY_MAX_FRAME_SIZE_LOG2, 1, 0, 0, DF, - g_third_stage_div_2_fir, 0, FIR_COMPENSATOR_DIV_2, - DECIMATOR_NO_FRAME_OVERLAP, 2}; - mic_array_decimator_config_t dc[2] = { - {&dcc, data[0], {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0}, - {&dcc, data[4], {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0} - }; - mic_array_decimator_configure(c_ds_output, 2, dc); - - mic_array_init_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - - //This test that if ready there is no exception - for(unsigned i=0;i<64;i++) - mic_array_get_next_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - printstrln("Normal case: Pass"); - - - //This test that if not ready there is an exception - for(unsigned i=0;i<4;i++){ - mic_array_frame_time_domain * current = mic_array_get_next_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - delay_milliseconds(1); - } - printstrln("Fail case: Fail"); - } -} - -int main(){ - - streaming chan c_4x_pdm_mic_0, c_4x_pdm_mic_1; - streaming chan c_ds_output[2]; - par{ - while(1){ - c_4x_pdm_mic_0 <: 0x55555555; - c_4x_pdm_mic_1 <: 0x55555555; - } - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic_0, c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic_1, c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - test_output(c_ds_output); - par(int i=0;i<4;i++)while(1); - } - return 0; -} diff --git a/legacy_tests/test_frame_drop/wscript b/legacy_tests/test_frame_drop/wscript deleted file mode 100644 index 503f2d4f..00000000 --- a/legacy_tests/test_frame_drop/wscript +++ /dev/null @@ -1,22 +0,0 @@ -def options(opt): - opt.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - bld.do_xcommon() - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/legacy_tests/test_frontend.py b/legacy_tests/test_frontend.py deleted file mode 100644 index e14dab29..00000000 --- a/legacy_tests/test_frontend.py +++ /dev/null @@ -1,26 +0,0 @@ -#!/usr/bin/env python -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import xmostest - -def do_frontend_test(channel_count, testlevel): - - resources = xmostest.request_resource("xsim") - - binary = 'test_pdm_interface/bin/CH{ch}/test_pdm_interface_CH{ch}.xe'.format(ch=channel_count) - - tester = xmostest.ComparisonTester(open('pdm_interface.expect'), - 'lib_mic_array', - 'lib_mic_array_frontend_tests', - 'frontend_test_%s'%testlevel, - {'channel_count':channel_count}) - - tester.set_min_testlevel(testlevel) - - xmostest.run_on_simulator(resources['xsim'], binary, - simargs=[], - tester = tester) - -def runtest(): - do_frontend_test(4, "smoke") - do_frontend_test(8, "smoke") diff --git a/legacy_tests/test_hires_delay/.cproject b/legacy_tests/test_hires_delay/.cproject deleted file mode 100644 index 404b60fa..00000000 --- a/legacy_tests/test_hires_delay/.cproject +++ /dev/null @@ -1,944 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_hires_delay/.project b/legacy_tests/test_hires_delay/.project deleted file mode 100644 index 3ab3dae4..00000000 --- a/legacy_tests/test_hires_delay/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_hires_delay - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_hires_delay/Makefile b/legacy_tests/test_hires_delay/Makefile deleted file mode 100644 index 2f640a57..00000000 --- a/legacy_tests/test_hires_delay/Makefile +++ /dev/null @@ -1,26 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_hires_delay - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_hires_delay/config.xscope b/legacy_tests/test_hires_delay/config.xscope deleted file mode 100644 index 15402889..00000000 --- a/legacy_tests/test_hires_delay/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_hires_delay/src/mic_array_conf.h b/legacy_tests/test_hires_delay/src/mic_array_conf.h deleted file mode 100644 index f95dfdfe..00000000 --- a/legacy_tests/test_hires_delay/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 8 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_hires_delay/src/test_hires_delay.xc b/legacy_tests/test_hires_delay/src/test_hires_delay.xc deleted file mode 100644 index 4f9ea54d..00000000 --- a/legacy_tests/test_hires_delay/src/test_hires_delay.xc +++ /dev/null @@ -1,105 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include "mic_array.h" -#include -#include -#include - -#define S_CHANS ((MIC_ARRAY_NUM_MICS + 3)/4) - -static unsigned make_id(unsigned sample_number, unsigned chan_number){ - return (sample_number&0xfffffff) + (chan_number<<28); -} - -static void unmake_id(unsigned id, unsigned &sample_number, unsigned &chan_number){ - sample_number = id&0xfffffff; - chan_number= id>>28; -} - -void producer(streaming chanend c_from_pdm_frontend[]){ - unsigned i=0; - while(1){ - for(unsigned ch=0;ch < MIC_ARRAY_NUM_MICS/S_CHANS;ch++){ - for(unsigned c=0;c id; - unsigned s, n; - unmake_id(id, s, n); - result[n] = s; - } - } - correct = 1; - for(unsigned ch=0;ch - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_lib_include/.project b/legacy_tests/test_lib_include/.project deleted file mode 100644 index a4d55467..00000000 --- a/legacy_tests/test_lib_include/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_lib_include - - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_lib_include/Makefile b/legacy_tests/test_lib_include/Makefile deleted file mode 100644 index 2d2e5bd6..00000000 --- a/legacy_tests/test_lib_include/Makefile +++ /dev/null @@ -1,26 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_lib_include - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_lib_include/config.xscope b/legacy_tests/test_lib_include/config.xscope deleted file mode 100644 index bfdf1f86..00000000 --- a/legacy_tests/test_lib_include/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_lib_include/src/mic_array_conf.h b/legacy_tests/test_lib_include/src/mic_array_conf.h deleted file mode 100644 index 5bed1526..00000000 --- a/legacy_tests/test_lib_include/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 13 -#define MIC_ARRAY_NUM_MICS 4 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_lib_include/src/test_lib_include.xc b/legacy_tests/test_lib_include/src/test_lib_include.xc deleted file mode 100644 index 6a7baec9..00000000 --- a/legacy_tests/test_lib_include/src/test_lib_include.xc +++ /dev/null @@ -1,3 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -int main(){return 0;} diff --git a/legacy_tests/test_lib_include/wscript b/legacy_tests/test_lib_include/wscript deleted file mode 100644 index 503f2d4f..00000000 --- a/legacy_tests/test_lib_include/wscript +++ /dev/null @@ -1,22 +0,0 @@ -def options(opt): - opt.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - bld.do_xcommon() - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/legacy_tests/test_metadata/.cproject b/legacy_tests/test_metadata/.cproject deleted file mode 100644 index ff409640..00000000 --- a/legacy_tests/test_metadata/.cproject +++ /dev/null @@ -1,928 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_metadata/.project b/legacy_tests/test_metadata/.project deleted file mode 100644 index e101ec45..00000000 --- a/legacy_tests/test_metadata/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_metadata - - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_metadata/Makefile b/legacy_tests/test_metadata/Makefile deleted file mode 100644 index 1c8ef14e..00000000 --- a/legacy_tests/test_metadata/Makefile +++ /dev/null @@ -1,26 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_metadata - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_metadata/config.xscope b/legacy_tests/test_metadata/config.xscope deleted file mode 100644 index 48864698..00000000 --- a/legacy_tests/test_metadata/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_metadata/src/mic_array_conf.h b/legacy_tests/test_metadata/src/mic_array_conf.h deleted file mode 100644 index 7e9676b2..00000000 --- a/legacy_tests/test_metadata/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 3 -#define MIC_ARRAY_NUM_MICS 4 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_metadata/src/test_metadata.xc b/legacy_tests/test_metadata/src/test_metadata.xc deleted file mode 100644 index d4b8a35b..00000000 --- a/legacy_tests/test_metadata/src/test_metadata.xc +++ /dev/null @@ -1,147 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include -#include -#include -#include - - -#include "mic_array.h" - -int data[4][THIRD_STAGE_COEFS_PER_STAGE*12]; - - -int window_fn(unsigned i, unsigned window_length){ - return((int)((double)INT_MAX*sqrt(0.5*(1.0 - cos(2.0 * 3.14159265359*(double)i / (double)(window_length-2)))))); -} - -void run_test(streaming chanend c_ds_output[1], unsigned frames, - mic_array_decimator_buffering_t buffering, int * window, unsigned DC, - const int * unsafe coefs, unsigned comp){ - - int max_overestimation = 0; - unsafe{ - mic_array_frame_time_domain audio[4]; - - unsigned buffer; //buffer index - memset(data, 0, sizeof(data)); - - //This will only work for a decimation factor of above 2 - mic_array_decimator_conf_common_t dcc = { - MIC_ARRAY_MAX_FRAME_SIZE_LOG2, - 0, - 0, - window, - DC, - coefs, - 0, - comp, - buffering, - frames}; - mic_array_decimator_config_t dc[1] = {{&dcc, data[0], {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0}}; - - mic_array_decimator_configure(c_ds_output, 1, dc); - - mic_array_init_time_domain_frame(c_ds_output, 1, buffer, audio, dc); - - for(unsigned i=0;i<1<<2;i++){ - - mic_array_frame_time_domain * c = mic_array_get_next_time_domain_frame(c_ds_output, 1, buffer, audio, dc); - - unsigned mask[4] = {0}; - - for(unsigned i=0;i<1<data[m][i]; - if (v<0)v=-v; - mask[m] |= v; - } - } - - for(unsigned i=0;i<4;i++){ - unsigned actual = clz(mask[i]); - unsigned result = clz(c->metadata[0].sig_bits[i]); - unsigned over = actual - result; - if (over > max_overestimation) - max_overestimation = over; - } - } - } - if((max_overestimation) >= 0 && (max_overestimation < 12)){ - printf("Pass\n"); - } else { - printf("Fail %d\n", max_overestimation); - } -} - - -void check_metadata(streaming chanend c_ds_output[1]){ - int window[1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2-1)]; - for(unsigned i=0;i<(1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2-1));i++) - window[i] = window_fn(i, 1< self.target_snr: - self.record_failure(out_file + " SNR is {}dB which is worse than target of {}dB".format(result, self.target_snr)) - xmostest.set_test_result(self.product, self.group, self.test, self.config, self.result, - output = output, env = self.env) - -class Spectral_Tester(xmostest.Tester): - def __init__(self, closeness, product, group, test, config = {}, env = {}): - super(Spectral_Tester, self).__init__() - self.closeness = closeness - self.register_test(product, group, test, config) - self.product = product - self.group = group - self.test = test - self.config = config - self.env = env - self.result = True - - def get_fft(self, wav_file): - audio_data, fs = sf.read(test_dir+wav_file) - f, Pxx_spec = welch(audio_data, fs, 'flattop', 512, scaling='spectrum') - # Ditch anything above 7.0kHz or below 100Hz - idxs = np.where(f < 7000) - idxs = np.where(f[idxs] > 100) - return f[idxs], np.sqrt(Pxx_spec[idxs]) - - def record_failure(self, failure_reason): - # Append a newline if there isn't one already - if not failure_reason.endswith('\n'): - failure_reason += '\n' - self.failures.append(failure_reason) - print ("ERROR: %s" % failure_reason), # Print without newline - self.result = False - - def run(self, output): - add_wav_headers(out_files) - for i in range(2): - result = np.isclose(self.get_fft(out_files[i]), self.get_fft(out_files[i+2]), rtol=self.closeness) - if not result.all(): - self.record_failure("Spectral response deviates between {} and {}: \n{}".format(out_files[i], out_files[i+2], result)) - xmostest.set_test_result(self.product, self.group, self.test, self.config, self.result, - output = output, env = self.env) - -class rms_tester(xmostest.Tester): - def __init__(self, max_variance, product, group, test, config = {}, env = {}): - super(rms_tester, self).__init__() - self.max_variance = max_variance - self.register_test(product, group, test, config) - self.product = product - self.group = group - self.test = test - self.config = config - self.env = env - self.result = True - - def record_failure(self, failure_reason): - # Append a newline if there isn't one already - if not failure_reason.endswith('\n'): - failure_reason += '\n' - self.failures.append(failure_reason) - print ("ERROR: %s" % failure_reason), # Print without newline - self.result = False - - def run(self, output): - add_wav_headers(out_files) - results = [analyze_channels(test_dir + test_file, rms_flat) for test_file in out_files] - ch_a_dual_std_ratio = results[0] / results[2] - ch_b_dual_std_ratio = results[1] / results[3] - ch_a_dual_std_ratio = 1 / ch_a_dual_std_ratio if ch_a_dual_std_ratio > 1 else ch_a_dual_std_ratio - ch_b_dual_std_ratio = 1 / ch_b_dual_std_ratio if ch_b_dual_std_ratio > 1 else ch_b_dual_std_ratio - - if ch_a_dual_std_ratio < target_ratio or ch_b_dual_std_ratio < target_ratio: - self.record_failure("RMS amplitudes of ch_a {} & ch_b {} of dual too different from mic_array. Raw results: {}".format(ch_a_dual_std_ratio, ch_b_dual_std_ratio, results)) - else: - print("RMS amplitude differences for ch_a: {} & ch_b: {}".format(ch_a_dual_std_ratio, ch_b_dual_std_ratio) ) - xmostest.set_test_result(self.product, self.group, self.test, self.config, self.result, - output = output, env = self.env) - -def do_mic_dual_test(testlevel, checker): - resources = xmostest.request_resource("axe") - - if checker == THDN: - tester = THD_N_Tester(target_snr, 'lib_mic_array', 'mic_dual', 'thd_noise_{}'.format(testlevel)) - elif checker == rms_flat: - tester = rms_tester(target_snr, 'lib_mic_array', 'mic_dual', 'amplitude_{}'.format(testlevel)) - elif checker == Spectral_Tester.get_fft: - tester = Spectral_Tester(closeness, 'lib_mic_array', 'mic_dual', 'spectral_{}'.format(testlevel)) - else: - fail("No checker passed to do_mic_dual_test") - - tester.set_min_testlevel(testlevel) - - binary = 'test_mic_dual/bin/test_mic_dual.xe' - xmostest.run_on_simulator(resources['axe'], binary, - simargs=[], - tester=tester) - xmostest.complete_all_jobs() - - -# Expects a tuple of length two of arg list -def create_test_pdm_signals(sox_args): - in_file_names = ["ch_a_src.wav", "ch_b_src.wav"] - out_file_names = ["ch_a.pdm", "ch_b.pdm"] - - cmd = "sox -n -c 1 -b 32 -r 16000 {} synth" - - for sox_arg, file_name in zip(sox_args, in_file_names): - this_cmd = cmd.format(test_dir + file_name).split() - this_cmd.append(str(AUDIO_LENGTH_S)) - this_cmd.extend(sox_arg) - print(" ".join(this_cmd)) - subprocess.call(this_cmd) - - # Run in parallel - def ptp0(): - pcm_to_pdm(test_dir + in_file_names[0], test_dir + out_file_names[0], 3072000, verbose = True) - def ptp1(): - pcm_to_pdm(test_dir + in_file_names[1], test_dir + out_file_names[1], 3072000, verbose = True) - proc = [] - for fn in [ptp0, ptp1]: - p = Process(target=fn) - p.start() - proc.append(p) - for p in proc: - p.join() - - -def add_wav_headers(file_list): - STARTUP_TRIM_LENGTH_S=0.1 #0.1 is enough to remove the startup glitch and seems to cut at zero cross (good for THD) - - cmd = "sox --endian little -c 1 -r 16000 -b 32 -e signed-integer {} {} trim {}" - for out_name in file_list: - in_name = out_name.rstrip(".wav") + ".raw" - this_cmd = cmd.format(test_dir + in_name, test_dir + out_name, STARTUP_TRIM_LENGTH_S) - subprocess.call(this_cmd.split()) - -def cleanup_files(): - files = os.listdir(test_dir) - tmp_audio_files = [i for i in files if i.endswith('.wav') or i.endswith('.raw') or i.endswith('.pdm')] - for tmp_file in tmp_audio_files: - del_this = test_dir+tmp_file - os.remove(del_this) - -def runtest(): - create_test_pdm_signals((["sine", "300"], ["sine", "1000"])) - do_mic_dual_test("smoke", THDN) - - # re-use the previous sine pdm signals - do_mic_dual_test("smoke", rms_flat) - - create_test_pdm_signals((["whitenoise"], ["white"])) - do_mic_dual_test("smoke", Spectral_Tester.get_fft) - - cleanup_files() - - diff --git a/legacy_tests/test_mic_dual/config.xscope b/legacy_tests/test_mic_dual/config.xscope deleted file mode 100644 index bfdf1f86..00000000 --- a/legacy_tests/test_mic_dual/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_mic_dual/gen_white_noise.sh b/legacy_tests/test_mic_dual/gen_white_noise.sh deleted file mode 100644 index 759a9e2a..00000000 --- a/legacy_tests/test_mic_dual/gen_white_noise.sh +++ /dev/null @@ -1 +0,0 @@ -sox -n -c 1 -b 32 -r 16000 white_noise.wav synth 10 whitenoise \ No newline at end of file diff --git a/legacy_tests/test_mic_dual/pcm_to_pdm.py b/legacy_tests/test_mic_dual/pcm_to_pdm.py deleted file mode 100644 index 824a5f60..00000000 --- a/legacy_tests/test_mic_dual/pcm_to_pdm.py +++ /dev/null @@ -1,379 +0,0 @@ -# Copyright 2019-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import os -import numpy as np -import argparse -from scipy import signal -import scipy.io.wavfile -import operator - -def decimate(x, q, n=None, ftype='iir', axis=-1, zero_phase=True): - """ - Downsample the signal after applying an anti-aliasing filter. - By default, an order 8 Chebyshev type I filter is used. A 30 point FIR - filter with Hamming window is used if `ftype` is 'fir'. - Parameters - ---------- - x : array_like - The signal to be downsampled, as an N-dimensional array. - q : int - The downsampling factor. When using IIR downsampling, it is recommended - to call `decimate` multiple times for downsampling factors higher than - 13. - n : int, optional - The order of the filter (1 less than the length for 'fir'). Defaults to - 8 for 'iir' and 20 times the downsampling factor for 'fir'. - ftype : str {'iir', 'fir'} or ``dlti`` instance, optional - If 'iir' or 'fir', specifies the type of lowpass filter. If an instance - of an `dlti` object, uses that object to filter before downsampling. - axis : int, optional - The axis along which to decimate. - zero_phase : bool, optional - Prevent phase shift by filtering with `filtfilt` instead of `lfilter` - when using an IIR filter, and shifting the outputs back by the filter's - group delay when using an FIR filter. The default value of ``True`` is - recommended, since a phase shift is generally not desired. - .. versionadded:: 0.18.0 - Returns - ------- - y : ndarray - The down-sampled signal. - See Also - -------- - resample : Resample up or down using the FFT method. - resample_poly : Resample using polyphase filtering and an FIR filter. - Notes - ----- - The ``zero_phase`` keyword was added in 0.18.0. - The possibility to use instances of ``dlti`` as ``ftype`` was added in - 0.18.0. - """ - - x = np.asarray(x) - q = operator.index(q) - - if n is not None: - n = operator.index(n) - - if ftype == 'fir': - if n is None: - half_len = 10 * q # reasonable cutoff for our sinc-like function - n = 2 * half_len - b, a = firwin(n+1, 1. / q, window='hamming'), 1. - elif ftype == 'iir': - if n is None: - n = 8 - system = signal.dlti(*signal.cheby1(n, 0.05, 0.95 / q)) - b, a = system.num, system.den - elif isinstance(ftype, dlti): - system = ftype._as_tf() # Avoids copying if already in TF form - b, a = system.num, system.den - else: - raise ValueError('invalid ftype') - - sl = [slice(None)] * x.ndim - a = np.asarray(a) - - if a.size == 1: # FIR case - b = b / a - if zero_phase: - y = resample_poly(x, 1, q, axis=axis, window=b) - else: - # upfirdn is generally faster than lfilter by a factor equal to the - # downsampling factor, since it only calculates the needed outputs - n_out = x.shape[axis] // q + bool(x.shape[axis] % q) - y = upfirdn(b, x, up=1, down=q, axis=axis) - sl[axis] = slice(None, n_out, None) - - else: # IIR case - if zero_phase: - y = signal.filtfilt(b, a, x, axis=axis, padlen = 1000, padtype='even') - else: - y = lfilter(b, a, x, axis=axis) - sl[axis] = slice(None, None, q) - - return y[sl] - -def delta_sigma_5th_order( data_in , output_length): - "This outputs a 1-bit delta sigma modulated data set from an input data set of floating point samples" - - # Coefficients - c = [0.791882, 0.304545, 0.069930, 0.009496, 0.000607]; - f = [0.000496, 0.001789]; - - # Initialization - s0 = s1 = s2 = s3 = s4 = 0.0; # Integrators - data_out = np.ones(output_length) - - for i in range(1, min(len(data_in),output_length)): - s4 = s4 + s3; - s3 = s3 + s2 - f[1]*s4; - s2 = s2 + s1; - s1 = s1 + s0 - f[0]*s2; - s0 = s0 + (data_in[i] - data_out[i-1]); - s = c[0]*s0 + c[1]*s1 + c[2]*s2 + c[3]*s3 + c[4]*s4; - - if s < 0.0: - data_out[i] = -1.0 - - return data_out - -def gcd(a, b): return gcd(b, a % b) if b else a - -def up_down_ratio(input_rate, output_rate): - i = int(input_rate) - o = int(output_rate) - d = gcd(i, o) - i = i / d - o = o / d - return o, i - -def get_prime_factors(input): - remainder = int(input) - # TODO extend this - primes = [2, 3, 5, 7, 11, 13, 17, 19] - nprime = 0 - factors = [] - while remainder != 1: - if remainder%primes[nprime] == 0: - factors.append(primes[nprime]) - remainder /= primes[nprime] - else: - nprime += 1 - return np.asarray(factors) - -# TODO -# add output file name as argument (easy) -# add support for pdm output rates (easy) -# add support for fractional rate convertions - -def pcm_to_pdm(in_wav_file, out_pdm_file, pdm_sample_rate, verbose = False): - - pcm_sample_rate, pcm = scipy.io.wavfile.read(in_wav_file, 'r') - - nsamples = pcm.shape[0] - - multi_channel_pcm = pcm.T - - if len(multi_channel_pcm.shape ) == 1: - multi_channel_pcm = np.reshape(multi_channel_pcm, (1, nsamples)) - - # FIXME this need a handler for float types - first_sample = multi_channel_pcm[0][0] - if isinstance( first_sample, ( int, np.int16, np.int32 ) ): - pcm_full_scale = np.iinfo(first_sample).max - if verbose: - print("Full scale PCM value: " + str(pcm_full_scale) + ' (Integer type PCM)') - else: - pcm_full_scale = 1.0 - if verbose: - print("Full scale PCM value: " + str(pcm_full_scale) + ' (Float type PCM)') - - nchannels = multi_channel_pcm.shape[0] - - upsample_ratio , downsample_ratio = up_down_ratio(pcm_sample_rate, pdm_sample_rate) - - if nchannels > 8: - print("Error: More than 8 channels is not supported, found " + str(nchannels) + ".") - return - - seconds = np.round(float(nsamples) / float(pcm_sample_rate), 3) - - if verbose: - print("PCM -> PDM") - print("Number of sample: " + str(nsamples) + ' ~ ' + str(seconds) + ' seconds.') - print("Channel count: " + str(nchannels)) - print("Upsample ratio: " + str(upsample_ratio)) - print("Downsample ratio: " + str(downsample_ratio)) - - # Stability limit - pdm_magnitude_stability_limit = 0.55 # Goes unstable at 0.57. We need this above 0.5 so we - # can test for overflow/wrap of top bit - - output_length = int(nsamples*upsample_ratio/downsample_ratio) - - pdm_samples = np.zeros((8, output_length)) - - max_abs_pcm_all_channels = 0. - for ch in range(nchannels): - if verbose: - print('processing channel ' + str(ch)) - pcm = multi_channel_pcm[ch] - - # limit the max pcm input to 0.4 - for stability of the modulator - pcm = np.asarray(pcm, dtype=np.float64) / pcm_full_scale - max_abs_pcm = max(abs(pcm)) - max_abs_pcm_all_channels = max(max_abs_pcm, max_abs_pcm_all_channels) - if max_abs_pcm >= pdm_magnitude_stability_limit: - - pcm /= max(abs(pcm)) - pcm *= pdm_magnitude_stability_limit - if verbose: - print('Abs max sample: '+ str(max_abs_pcm) +' limiting the abs max sample to ' + str(pdm_magnitude_stability_limit)) - else : - if verbose: - print('No sample limiting applied') - # TODO do this in chunks to save memory - up_sampled_pcm = signal.resample_poly(pcm, upsample_ratio, downsample_ratio) - - pdm_samples[ch] = delta_sigma_5th_order(up_sampled_pcm, output_length ) - - # Write output to file - # Convert from [-1, 1] -> [0, 1] range - pdm_samples[ch] = (pdm_samples[ch]*0.5) + np.ones(len(pdm_samples[ch]))*0.5 - - # pdm_samples = np.flip(pdm_samples, 0) - pdm_samples = np.flipud(pdm_samples) - - my_bytes = np.array(pdm_samples, dtype=np.uint8) - b = np.packbits(my_bytes.T, axis = -1) - - print("Max abs value {}".format(max_abs_pcm_all_channels)) - - fp = open(out_pdm_file,'wb') - - b.tofile(fp) - return - -def butter_highpass(cutoff, fs, order=5): - nyq = 0.5 * fs - normal_cutoff = cutoff / nyq - b, a = signal.butter(order, normal_cutoff, btype='high', analog=False) - return b, a - -def pdm_to_pcm(input_file, out_file, pdm_sample_rate, pcm_sample_rate, - desired_max_abs, - preserve_all_channels=False, verbose=False, apply_recording_conditioning=False): - - if verbose: - print("PDM -> PCM") - - binary_file = open(input_file, "rb") - - if verbose: - print('File length: ' + str(os.stat(input_file).st_size) + ' bytes') - - # Read the whole file at once - input_data = bytearray(binary_file.read()) - - nsamples = len(input_data) - - input_data = np.unpackbits(input_data) - - multi_channel_pdm = np.reshape(input_data, (len(input_data)/8, -1)).T - - non_zero_channel = [] - if not preserve_all_channels: - for ch in range(8): - if sum(multi_channel_pdm[ch]) != 0: - non_zero_channel.append(ch) - if verbose: - print('Keeping channel ' + str(ch)) - else: - for ch in range(8): - non_zero_channel.append(ch) - if verbose: - print('Keeping channel ' + str(ch)) - - nchannels = len(non_zero_channel) - - upsample_ratio , downsample_ratio = up_down_ratio(pdm_sample_rate, pcm_sample_rate) - - seconds = np.round(float(nsamples) / float(pdm_sample_rate), 3) - - if verbose: - print("Number of sample: " + str(nsamples) + ' ~ ' + str(seconds) + ' seconds.') - print("Input rate: " + str(pdm_sample_rate) + 'Hz') - print("Output rate: " + str(pcm_sample_rate) + 'Hz') - print("Channel count: " + str(nchannels)) - print("Upsample ratio: " + str(upsample_ratio)) - print("Downsample ratio: " + str(downsample_ratio)) - - pcm = np.zeros((nchannels, nsamples*upsample_ratio/downsample_ratio), dtype=np.float64) - - factors = get_prime_factors(downsample_ratio) - - factors = np.flipud(factors) - - for ch in range(nchannels): - if verbose: - print('processing channel ' + str(ch)) - pdm_ch = non_zero_channel[ch] - - pdm = np.zeros(nsamples, dtype=np.float64) - pdm = multi_channel_pdm[pdm_ch]*2.0 - pdm -= np.ones(len(multi_channel_pdm[ch])) - - # TODO do this in chunks to save memory - if upsample_ratio != 1: - t = signal.resample_poly(pdm, upsample_ratio, 1) - else: - t = pdm - - for f in factors: - t = decimate(t, f, zero_phase = True, n = 21) - - pcm[ch] = t[:len(pcm[ch] )] - - - if apply_recording_conditioning: - - # high pass filter to removed everything below 30Hz - b, a = butter_highpass(30., pcm_sample_rate, order=5) - for ch in range(nchannels): - pcm[ch] = signal.filtfilt(b, a, pcm[ch], padlen = 1000, padtype='even') - pcm[ch][0] = 0.0 - - # Scale the output to the requested level - m = np.amax(pcm) - - # make it full scale - pcm /= m - pcm *= desired_max_abs - - scipy.io.wavfile.write(out_file, pcm_sample_rate, pcm.T) - return - -if __name__ == '__main__': - parser = argparse.ArgumentParser( 'PDM and PCM converter.' ) - parser.add_argument( 'in_file' ) - parser.add_argument( 'out_file' ) - - parser.add_argument( '--apply-conditioning', action='store_true', - help='30Hz high pass filter and gain.') - - parser.add_argument( '--output-rate', type=float, default=16000.0, - help='The sample rate out the output', - metavar='Hz') - - parser.add_argument( '--abs-pcm-value', type=float, default=1.0, - help='Maximum absolute value of output') - - parser.add_argument( '--verbose', action='store_true') - parser.add_argument( '--make-pcm', action='store_true') - - - args = parser.parse_args() - - verbose_enabled = args.verbose - - in_file = args.in_file - out_file = args.out_file - - pdm_clock_rate = 3072000.0 - - if verbose_enabled: - print('Input file: ' + str(in_file)) - print('Output file: ' + str(out_file)) - - if not args.make_pcm: - pcm_to_pdm(in_file, out_file, pdm_clock_rate, verbose=verbose_enabled) - else: - - apply_conditioning = args.apply_conditioning - - pdm_to_pcm(in_file, out_file, pdm_clock_rate, args.output_rate, - args.abs_pcm_value, - verbose=verbose_enabled, - apply_recording_conditioning = apply_conditioning) - diff --git a/legacy_tests/test_mic_dual/src/mic_array_conf.h b/legacy_tests/test_mic_dual/src/mic_array_conf.h deleted file mode 100644 index a5e2c450..00000000 --- a/legacy_tests/test_mic_dual/src/mic_array_conf.h +++ /dev/null @@ -1,18 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 8 -#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_DECIMATION_FACTOR 6 -#define MIC_FRAME_BUFFERS 2 -#define MIC_CHANNELS 4 -#define MIC_DECIMATORS 1 - -#define MIC_DUAL_ENABLED 1 -#define MIC_DUAL_FRAME_SIZE (240) - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_mic_dual/src/test_mic_dual.xc b/legacy_tests/test_mic_dual/src/test_mic_dual.xc deleted file mode 100644 index 61cdc5fd..00000000 --- a/legacy_tests/test_mic_dual/src/test_mic_dual.xc +++ /dev/null @@ -1,260 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include -#include -#include "mic_array.h" - -//Note XMOS test runs from directory up hence adding dir to filename -//Expects binary file with one byte per bit. Byte value is either 0 or 1 -#define PDM_FILE_NAME_A "test_mic_dual/ch_a.pdm" -#define PDM_FILE_NAME_B "test_mic_dual/ch_b.pdm" - -#define PCM_FILE_NAME_STD_A "test_mic_dual/ch_a_std.raw" -#define PCM_FILE_NAME_STD_B "test_mic_dual/ch_b_std.raw" - -#define PCM_FILE_NAME_DUAL_A "test_mic_dual/ch_a_dual.raw" -#define PCM_FILE_NAME_DUAL_B "test_mic_dual/ch_b_dual.raw" - -in buffered port:32 p_pdm_mics = XS1_PORT_1A; -unsafe{ - buffered port:32 * unsafe p_ptr = (buffered port:32 * unsafe) &p_pdm_mics; -} - -//Note unusual casting of channel to a port. i.e. we output directly onto channel rather than port -unsafe{ - void call_mic_dual_pdm_rx_decimate(chanend c_mic_dual_pdm, streaming chanend c_ds_output[], streaming chanend c_ref_audio[]){ - p_ptr = ( buffered port:32 * unsafe ) &c_mic_dual_pdm; - //printf("%p\n", *p_ptr); - mic_dual_pdm_rx_decimate(*p_ptr, c_ds_output[0], c_ref_audio); - } -} - -extern void pdm_rx_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -unsafe{ - void call_pdm_rx(chanend c_mic_dual_pdm, streaming chanend c_4x_pdm_mic_0, streaming chanend ?c_4x_pdm_mic_1){ - p_ptr = ( buffered port:32 * unsafe ) &c_mic_dual_pdm; - //printf("%p\n", *p_ptr); - mic_array_pdm_rx(*p_ptr, c_4x_pdm_mic_0, c_4x_pdm_mic_1); - } -} - - -void get_pdm_from_file(chanend c_mic_dual_pdm, streaming chanend c_mic_array_pdm){ - FILE * unsafe pdm_file[2]; - pdm_file[0] = fopen ( PDM_FILE_NAME_A , "rb" ); - pdm_file[1] = fopen ( PDM_FILE_NAME_B , "rb" ); - - - if ((pdm_file[0]==NULL)) { - printf("cannot open (%s)\n", PDM_FILE_NAME_A); - exit(1); - } - if ((pdm_file[1]==NULL)) { - printf("cannot open (%s)\n", PDM_FILE_NAME_B); - exit(1); - } - - //Get size of first file (assume they are the same size) - fseek(pdm_file[0], 0L, SEEK_END); - unsigned sz = ftell(pdm_file[0]); - rewind(pdm_file[0]); - - unsigned pdm_word_count = 0; - unsigned char pdm_chunk[2][32]; - while(1){ - if (32 != fread (pdm_chunk[0], 1, 32, (FILE *)pdm_file[0])) { - printf("\nEnd of file reading %s\n", PDM_FILE_NAME_A); - exit(0); - } - if (32 != fread (pdm_chunk[1], 1, 32, (FILE *)pdm_file[1])) { - printf("\nEnd of file reading %s\n", PDM_FILE_NAME_A); - exit(0); - } - pdm_word_count += 1; - - if((pdm_word_count & 0xfff) == 0) printf("Simulation progress: %d%%\r", (pdm_word_count * 100) / (sz /32)); - - unsigned pdm_word[2] = {0, 0}; - for (unsigned p=0;p<2;p++){ - for(unsigned i=0;i<32;i++){ - pdm_word[p] |= pdm_chunk[p][i] ? 0x1 << i : 0; - //printf("%d", pdm_chunk[i]); - } - //printf("\n"); - } - - //ZIP 2 PDMS into SINGLE STREAM for mic_dual - unsigned long long tmp64 = zip(pdm_word[0], pdm_word[1], 0); - - unsigned port_b = tmp64 >> 32; - unsigned port_a = tmp64; - //printbinln(port_a); - //printbinln(port_b); - - outuint(c_mic_dual_pdm, port_a); - outuint(c_mic_dual_pdm, port_b); - - - //Now build word for mic_array - //We could do this quicker with zip but this works - for(unsigned i=0;i<8;i++){ - unsigned port_val = 0; - for(unsigned j=0;j<4;j++){ - unsigned pdm_idx = 4 * i + j; - port_val |= pdm_chunk[0][pdm_idx] ? 0x1 << (8 * j) : 0x0; - port_val |= pdm_chunk[1][pdm_idx] ? 0x2 << (8 * j) : 0x0; - } - c_mic_array_pdm <: port_val; - } - } -} - - -int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - -void collect_output_std( streaming chanend c_ds_output[1]){ - unsafe{ - FILE * unsafe pcm_file[2]; - pcm_file[0] = fopen ( PCM_FILE_NAME_STD_A, "wb" ); - pcm_file[1] = fopen ( PCM_FILE_NAME_STD_B , "wb" ); - - if ((pcm_file[0]==NULL)) { - printf("file cannot be opened (%s)\n", PCM_FILE_NAME_STD_A); - exit(1); - } - if ((pcm_file[1]==NULL)) { - printf("file cannot be opened (%s)\n", PCM_FILE_NAME_STD_B); - exit(1); - } - - unsigned buffer; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - memset(mic_array_data, 0, MIC_DECIMATORS*MIC_CHANNELS*THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR*sizeof(int)); - - mic_array_decimator_conf_common_t decimator_common_config = { - MIC_DUAL_FRAME_SIZE, - 1, - 0, - 0, - MIC_DECIMATION_FACTOR, - g_third_stage_div_6_fir, - 0, - FIR_COMPENSATOR_DIV_6, - DECIMATOR_NO_FRAME_OVERLAP, - MIC_FRAME_BUFFERS - }; - - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS] = { - { - &decimator_common_config, - mic_array_data[0], // The storage area for the output decimator - {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, // Microphone gain compensation (turned off) - MIC_CHANNELS, - 0 // Async interface disabled - } - }; - - mic_array_decimator_configure(c_ds_output, MIC_DECIMATORS, decimator_config); - mic_array_init_time_domain_frame(c_ds_output, MIC_DECIMATORS, buffer, audio_frame, decimator_config); - - while(1){ - // Get lib_mic_array - mic_array_frame_time_domain * current_frame; - current_frame = mic_array_get_next_time_domain_frame(c_ds_output, MIC_DECIMATORS, buffer, audio_frame, decimator_config); - // printf("mic_array\n"); - - for(unsigned i=0;idata[0][i]; - int ch1 = current_frame->data[1][i]; - - // printf("ch0: %d\t ch1: %d\n", ch0, ch1); - fwrite(&ch0, sizeof(ch0), 1, (FILE *)pcm_file[0]); - fwrite(&ch1, sizeof(ch1), 1, (FILE *)pcm_file[1]); - } - } -} -}//unsafe - -void collect_output_dual(streaming chanend c_ds_output_dual[1]){ - unsafe{ - FILE * unsafe pcm_file[2]; - pcm_file[0] = fopen ( PCM_FILE_NAME_DUAL_A , "wb" ); - pcm_file[1] = fopen ( PCM_FILE_NAME_DUAL_B , "wb" ); - - if ((pcm_file[0]==NULL)) { - printf("file cannot be opened (%s)\n", PCM_FILE_NAME_DUAL_A); - exit(1); - } - if ((pcm_file[1]==NULL)) { - printf("file cannot be opened (%s)\n", PCM_FILE_NAME_DUAL_B); - exit(1); - } - - // No init for mic_dual - - - while(1){ - // Get mic_dual - unsigned addr = 0; - c_ds_output_dual[0] :> addr; - // printf("mic_dual\n"); - - for(unsigned i=0;i int _; - for(unsigned i=0;i<2;i++) c_ref_audio[i] <: 0; - } -} - -void test2ch(){ - - //mic_dual plumbing - chan c_mic_dual_pdm; //This uses primatives rather than XC operators so has normal chan - streaming chan c_ds_output_dual[1], c_ref_audio[2]; - - //mic_array plumbing - streaming chan c_mic_array_pdm; - streaming chan c_ds_output[1], c_4x_pdm_mic_0; - - par { - get_pdm_from_file(c_mic_dual_pdm, c_mic_array_pdm); - - //mic_dual - ref_audio(c_ref_audio); - call_mic_dual_pdm_rx_decimate(c_mic_dual_pdm, c_ds_output_dual, c_ref_audio); - collect_output_dual(c_ds_output_dual); - - - //standard lib_mic_array - pdm_rx_debug(c_mic_array_pdm, c_4x_pdm_mic_0, null); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic_0, c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - collect_output_std(c_ds_output); - - - } -} - -int main(){ - - test2ch(); - return 0; -} diff --git a/legacy_tests/test_mic_dual/test_all_thd.sh b/legacy_tests/test_mic_dual/test_all_thd.sh deleted file mode 100644 index f29ced27..00000000 --- a/legacy_tests/test_mic_dual/test_all_thd.sh +++ /dev/null @@ -1,40 +0,0 @@ -AUDIO_LENGTH_S=10 -STARTUP_TRIM_LENGTH_S=0.1 - -#Generate sines -echo "Generating sine waves for test" -sox -n -c 1 -b 32 -r 16000 ch_a_src.wav synth $AUDIO_LENGTH_S sine 1000 -sox -n -c 1 -b 32 -r 16000 ch_b_src.wav synth $AUDIO_LENGTH_S sine 300 - -wait $! - -#PCM to PDM -python3 pcm_to_pdm.py --output-rate 3072000 --verbose ch_a_src.wav ch_a.pdm & -pids=$! -python3 pcm_to_pdm.py --output-rate 3072000 --verbose ch_b_src.wav ch_b.pdm & -pids+=" "$! - -wait $pids - - -#Run simulation -echo "Running firmware" -axe bin/test_mic_dual.xe - -#Add wav headers onto output PCM binaries -#Note we remove the first 100ms which adds distortion due to startup noise (init state) in lib_mic_array -sox --endian little -c 1 -r 16000 -b 32 -e signed-integer ch_a_std.raw ch_a_std.wav trim $STARTUP_TRIM_LENGTH_S -sox --endian little -c 1 -r 16000 -b 32 -e signed-integer ch_b_std.raw ch_b_std.wav trim $STARTUP_TRIM_LENGTH_S -sox --endian little -c 1 -r 16000 -b 32 -e signed-integer ch_a_dual.raw ch_a_dual.wav trim $STARTUP_TRIM_LENGTH_S -sox --endian little -c 1 -r 16000 -b 32 -e signed-integer ch_b_dual.raw ch_b_dual.wav trim $STARTUP_TRIM_LENGTH_S - -#Do the THD calc -python3 thdncalculator.py ch_a_std.wav -python3 thdncalculator.py ch_b_std.wav -python3 thdncalculator.py ch_a_dual.wav -python3 thdncalculator.py ch_b_dual.wav - -#Remove tmp files -rm *.wav -rm *.pdm -rm *.raw \ No newline at end of file diff --git a/legacy_tests/test_mic_dual/thdncalculator.py b/legacy_tests/test_mic_dual/thdncalculator.py deleted file mode 100755 index ef051098..00000000 --- a/legacy_tests/test_mic_dual/thdncalculator.py +++ /dev/null @@ -1,142 +0,0 @@ -# Copyright 2019-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import sys, os -from scipy.signal import blackmanharris -from numpy.fft import rfft, irfft -from numpy import argmax, sqrt, mean, absolute, arange, log10 -import numpy as np - -use_soundfile = False - - -try: - import soundfile as sf - print("using soundfile") - use_soundfile = True -except ImportError: - from scikits.audiolab import Sndfile - print("using scikits.audiolab") - - -def rms_flat(a, sample_rate): - """ - Return the root mean square of all the elements of *a*, flattened out. - """ - return sqrt(mean(absolute(a)**2)) - - -def find_range(f, x): - """ - Find range between nearest local minima from peak at index x - """ - for i in arange(x+1, len(f)): - if f[i+1] >= f[i]: - uppermin = i - break - for i in arange(x-1, 0, -1): - if f[i] <= f[i-1]: - lowermin = i + 1 - break - return (lowermin, uppermin) - - -def THDN(signal, sample_rate): - """ - Measure the THD+N for a signal and print the results - - Prints the estimated fundamental frequency and the measured THD+N. This is - calculated from the ratio of the entire signal before and after - notch-filtering. - - Currently this tries to find the "skirt" around the fundamental and notch - out the entire thing. A fixed-width filter would probably be just as good, - if not better. - """ - # Get rid of DC and window the signal - signal -= mean(signal) # TODO: Do this in the frequency domain, and take any skirts with it? - windowed = signal * blackmanharris(len(signal)) # TODO Kaiser? - - # Measure the total signal before filtering but after windowing - total_rms = rms_flat(windowed, sample_rate) - - # Find the peak of the frequency spectrum (fundamental frequency), and - # filter the signal by throwing away values between the nearest local - # minima - f = rfft(windowed) - i = argmax(abs(f)) - print('Frequency: %f Hz' % (sample_rate * (i / len(windowed)))) # Not exact - lowermin, uppermin = find_range(abs(f), i) - f[lowermin: uppermin] = 0 - - # Transform noise back into the signal domain and measure it - # TODO: Could probably calculate the RMS directly in the frequency domain instead - noise = irfft(f) - THDN = rms_flat(noise, sample_rate) / total_rms - - result = "THD+N: %.4f%% or %.1f dB" % (THDN * 100, 20 * log10(THDN)) - print(result) - - return 20 * log10(THDN) - - -def load(filename): - """ - Load a wave file and return the signal, sample rate and number of channels. - - Can be any format that libsndfile supports, like .wav, .flac, etc. - """ - if use_soundfile: - wave_file = sf.SoundFile(filename) - signal = wave_file.read() - else: - wave_file = Sndfile(filename, 'r') - signal = wave_file.read_frames(wave_file.nframes) - - channels = wave_file.channels - sample_rate = wave_file.samplerate - - return signal, sample_rate, channels - - -def analyze_channels(filename, function): - """ - Given a filename, run the given analyzer function on each channel of the - file - """ - signal, sample_rate, channels = load(filename) - print('Analyzing "' + filename + '" SR: ' + str(sample_rate) + 'Hz...') - result = None - - if channels == 1: - # Monaural - result = function(signal, sample_rate) - elif channels == 2: - # Stereo - if np.array_equal(signal[:, 0], signal[:, 1]): - print('-- Left and Right channels are identical --') - function(signal[:, 0], sample_rate) - else: - print('-- Left channel --') - function(signal[:, 0], sample_rate) - print('-- Right channel --') - function(signal[:, 1], sample_rate) - else: - # Multi-channel - for ch_no, channel in enumerate(signal.transpose()): - print('-- Channel %d --' % (ch_no + 1)) - function(channel, sample_rate) - - if(result): - return result - -files = sys.argv[1:] -if files: - for filename in files: - try: - analyze_channels(filename, THDN) - except Exception as e: - print('Couldn\'t analyze "' + filename + '"') - print(e) - print('') -else: - sys.exit("You must provide at least one file to analyze") diff --git a/legacy_tests/test_mic_dual/wscript b/legacy_tests/test_mic_dual/wscript deleted file mode 100644 index 503f2d4f..00000000 --- a/legacy_tests/test_mic_dual/wscript +++ /dev/null @@ -1,22 +0,0 @@ -def options(opt): - opt.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - bld.do_xcommon() - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/legacy_tests/test_mic_dual_timing.py b/legacy_tests/test_mic_dual_timing.py deleted file mode 100644 index b8fa8559..00000000 --- a/legacy_tests/test_mic_dual_timing.py +++ /dev/null @@ -1,46 +0,0 @@ -#!/usr/bin/env python -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import xmostest - -class simple_pass_fail(xmostest.Tester): - def __init__(self, product, group, test, config = {}, env = {}): - super(simple_pass_fail, self).__init__() - self.register_test(product, group, test, config) - self.product = product - self.group = group - self.test = test - self.config = config - self.env = env - self.result = True - - def record_failure(self, failure_reason): - # Append a newline if there isn't one already - if not failure_reason.endswith('\n'): - failure_reason += '\n' - self.failures.append(failure_reason) - print ("ERROR: %s" % failure_reason), # Print without newline - self.result = False - - def run(self, output): - for line in output: - if ("ERROR" in line) or ("Fail" in line) or ("FAIL" in line) or ("Error" in line): - self.record_failure(line) - - xmostest.set_test_result(self.product, self.group, self.test, self.config, self.result, - output = output, env = self.env) - - -def do_test(testlevel): - - resources = xmostest.request_resource("xsim") - - tests = ["BLOCK_SIZE_1", "BLOCK_SIZE_240"] - for test in tests: - binary = 'test_mic_dual_timing/bin/{}/test_mic_dual_timing_{}.xe'.format(test, test) - tester = simple_pass_fail('lib_mic_array', 'mic_dual', 'timing_{}_{}'.format(test, testlevel)) - xmostest.run_on_simulator(resources['xsim'], binary, tester = tester) - - -def runtest(): - do_test("smoke") diff --git a/legacy_tests/test_mic_dual_timing/Makefile b/legacy_tests/test_mic_dual_timing/Makefile deleted file mode 100644 index f5df7067..00000000 --- a/legacy_tests/test_mic_dual_timing/Makefile +++ /dev/null @@ -1,31 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS_BLOCK_SIZE_240 = -Os -g -report -DMIC_DUAL_FRAME_SIZE=240 -DN_LOOPS_TO_TEST=1 -XCC_FLAGS_BLOCK_SIZE_1 = -Os -g -report -DMIC_DUAL_FRAME_SIZE=1 -DN_LOOPS_TO_TEST=100 - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -SOURCE_DIRS = src - -INCLUDE_DIRS = src - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_mic_dual_timing/src/mic_array_conf.h b/legacy_tests/test_mic_dual_timing/src/mic_array_conf.h deleted file mode 100644 index 44aa868e..00000000 --- a/legacy_tests/test_mic_dual_timing/src/mic_array_conf.h +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 8 // Don't care for mic_dual, used FRAME_SIZE -#define MIC_ARRAY_NUM_MICS 4 // Don't care for mic_dual, always 2 - -#define MIC_DECIMATION_FACTOR 6 // Don't care for mic_dual, always 6 -#define MIC_FRAME_BUFFERS 2 // Don't care - Defined within mic_dual.xc -#define MIC_CHANNELS 4 // Don't care for mic_dual, always 2 -#define MIC_DECIMATORS 1 // Don't care for mic_dual - -#define MIC_DUAL_ENABLED 1 -// Defined in compiler flags: -// #define MIC_DUAL_FRAME_SIZE 1 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_mic_dual_timing/src/test_mic_dual_timing.xc b/legacy_tests/test_mic_dual_timing/src/test_mic_dual_timing.xc deleted file mode 100644 index e3b77a5c..00000000 --- a/legacy_tests/test_mic_dual_timing/src/test_mic_dual_timing.xc +++ /dev/null @@ -1,126 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include -#include -#include -#include "mic_array.h" - -#ifndef N_LOOPS_TO_TEST -#define N_LOOPS_TO_TEST 50 -#endif - -const unsigned ticks_per_s = 100000000; - - -in buffered port:32 p_pdm_mics = XS1_PORT_1A; -unsafe{ - buffered port:32 * unsafe p_ptr = (buffered port:32 * unsafe) &p_pdm_mics; -} - -//Note unusual casting of channel to a port. i.e. we output directly onto channel rather than port -unsafe{ - void call_mic_dual_pdm_rx_decimate(chanend c_mic_dual_pdm, streaming chanend c_ds_output[], streaming chanend c_ref_audio[]){ - p_ptr = ( buffered port:32 * unsafe ) &c_mic_dual_pdm; - //printf("%p\n", *p_ptr); - mic_dual_pdm_rx_decimate(*p_ptr, c_ds_output[0], c_ref_audio); - } -} - -unsigned get_random(unsigned x){ - crc32(x, -1, 0xEDB88320); - return x; -} - - -void gen_pdm(chanend c_mic_dual_pdm){ - const unsigned pdm_hz = 3072000; - const unsigned serdes_length = 32; - const unsigned port_time_ticks = ticks_per_s / ((pdm_hz * 2)/ serdes_length); //2 because it's DDR - - unsigned random = 0xedededed; - set_thread_fast_mode_on(); //burn!! - - timer tmr; - unsigned time_trig; - tmr :> time_trig; - - while(1){ - random = get_random(random); - - tmr when timerafter(time_trig) :> void; - time_trig += port_time_ticks; - outuint(c_mic_dual_pdm, random); - - random = get_random(random); - - tmr when timerafter(time_trig) :> void; - time_trig += port_time_ticks; - outuint(c_mic_dual_pdm, random); - } -} - - -void test_timing(streaming chanend c_ds_output_dual[1]){ -unsafe{ - // No init for mic_dual - const unsigned fs = 16000; - const unsigned max_ticks = (unsigned)((unsigned long long)ticks_per_s * MIC_DUAL_FRAME_SIZE / fs); - const int headroom_ticks = 5; //Arbitrary 50ns headroom - long long total_headroom_ticks = 0; - int min_head_room = INT_MAX; - - set_thread_fast_mode_on(); //burn!! - c_ds_output_dual[0] :> unsigned _; //Flush first value as we have to wait for pipe to fill - - timer tmr; - unsigned this_time, old_time; - tmr :> this_time; - old_time = this_time; //Set old time to be in future because first iter takes longer - - for (int i = 0; i < N_LOOPS_TO_TEST; i++) { //Start at -1 because we ignore first loop - // Get mic_dual - unsigned addr = 0; - c_ds_output_dual[0] :> addr; - tmr :> this_time; - unsigned time = this_time - old_time; - printintln(time); - int this_headroom = (int)max_ticks - (int)time; - if (i >= 0)total_headroom_ticks += this_headroom; - if (this_headroom < min_head_room) min_head_room = this_headroom; - if (this_headroom < headroom_ticks){ - printf("FAIL: mic_dual took: %u ticks on cycle %d, limit: %u\n", time, i, max_ticks + headroom_ticks); - } - old_time = this_time; - } - // All good - printf("Test PASS with average headroom_ticks of %d over %d iterations, worst case %d\n", (int)(total_headroom_ticks / N_LOOPS_TO_TEST), N_LOOPS_TO_TEST, min_head_room); - exit(0); -}//unsafe -} - -void ref_audio(streaming chanend c_ref_audio[]){ - set_thread_fast_mode_on(); //burn!! - while(1){ - for(unsigned i=0;i<2;i++) c_ref_audio[i] :> int _; - for(unsigned i=0;i<2;i++) c_ref_audio[i] <: 0; - } -} - -int main(){ - chan c_mic_dual_pdm; //This uses primatives rather than XC operators so has normal chan - streaming chan c_ds_output_dual[1], c_ref_audio[2]; - - par { - gen_pdm(c_mic_dual_pdm); - - //mic_dual - ref_audio(c_ref_audio); - call_mic_dual_pdm_rx_decimate(c_mic_dual_pdm, c_ds_output_dual, c_ref_audio); - test_timing(c_ds_output_dual); - par (int i = 0; i < 4; i++) {{set_thread_fast_mode_on(); while(1);}} //burn remaining threads - } - return 0; -} diff --git a/legacy_tests/test_mic_dual_timing/wscript b/legacy_tests/test_mic_dual_timing/wscript deleted file mode 100644 index cd51301b..00000000 --- a/legacy_tests/test_mic_dual_timing/wscript +++ /dev/null @@ -1,69 +0,0 @@ -import os -from waflib import Options, Errors -from waflib.Build import BuildContext, CleanContext - -CONFIGS = [ - 'BLOCK_SIZE_240', - 'BLOCK_SIZE_1', -] - -def create_waf_contexts(configs): - for test_name in configs: - for ctx in (BuildContext, CleanContext): - raw_context = ctx.__name__.replace('Context', '').lower() - - class tmp(ctx): - cmd = raw_context + '_' + test_name - variant = test_name - variant = os.path.split(os.getcwd())[1] + '_' + variant - -create_waf_contexts(CONFIGS) - -def options(opt): - opt.load('xwaf.xcommon') - - -def configure(conf): - opt.add_option('--config', action='store', default='', - help='Choose among the supported configurations') - conf.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - - if not bld.variant: - build_configs = [ - c for c in CONFIGS if c == bld.options.config - ] - - if len(build_configs) == 0: - bld.fatal('specify a config with --config.\nAvailable configs: {}'.format(', '.join(CONFIGS))) - return - - build_commands = ['{}_{}'.format(bld.cmd, c) for c in build_configs] - print("build_commands = {}".format(build_commands)) - - if not build_commands: - bld.fatal/( - '{} does not match any configs'.format(bld.options.config)) - - cmd_str = {'build': 'Building', 'clean': 'Cleaning', 'list': "Listing"}[bld.cmd] - print('{} configs:\n {}'.format(cmd_str, '\n '.join( - build_configs))) - if not bld.cmd == 'list': - Options.commands = build_commands + Options.commands - return - - bld.do_xcommon() - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/legacy_tests/test_output/.cproject b/legacy_tests/test_output/.cproject deleted file mode 100644 index 8ee68abd..00000000 --- a/legacy_tests/test_output/.cproject +++ /dev/null @@ -1,1001 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_output/.project b/legacy_tests/test_output/.project deleted file mode 100644 index d36986bc..00000000 --- a/legacy_tests/test_output/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_output - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_output/MIC-ARRAY-1V0.xn b/legacy_tests/test_output/MIC-ARRAY-1V0.xn deleted file mode 100644 index e8efb894..00000000 --- a/legacy_tests/test_output/MIC-ARRAY-1V0.xn +++ /dev/null @@ -1,115 +0,0 @@ - - - Board - XS2 MC Audio - - tileref tile[2] - tileref usb_tile - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_output/Makefile b/legacy_tests/test_output/Makefile deleted file mode 100644 index 935b9f67..00000000 --- a/legacy_tests/test_output/Makefile +++ /dev/null @@ -1,26 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = MIC-ARRAY-1V0 - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_output - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_i2c lib_i2s lib_mic_array lib_mic_array_board_support - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_output/config.xscope b/legacy_tests/test_output/config.xscope deleted file mode 100644 index b12b3452..00000000 --- a/legacy_tests/test_output/config.xscope +++ /dev/null @@ -1,28 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_output/src/mic_array_conf.h b/legacy_tests/test_output/src/mic_array_conf.h deleted file mode 100644 index 67dde803..00000000 --- a/legacy_tests/test_output/src/mic_array_conf.h +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 3 -#define MIC_ARRAY_NUM_MICS 8 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_output/src/test_output.xc b/legacy_tests/test_output/src/test_output.xc deleted file mode 100644 index ca7550e4..00000000 --- a/legacy_tests/test_output/src/test_output.xc +++ /dev/null @@ -1,272 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "mic_array.h" -#include "mic_array_board_support.h" - -#include "i2c.h" -#include "i2s.h" - -#define DF 2 //Decimation Factor - -on tile[0]:mabs_led_ports_t leds = MIC_BOARD_SUPPORT_LED_PORTS; -on tile[0]:in port p_buttons = XS1_PORT_4A; - -on tile[0]: in port p_pdm_clk = XS1_PORT_1E; -on tile[0]: in buffered port:32 p_pdm_mics = XS1_PORT_8B; -on tile[0]: in port p_mclk = XS1_PORT_1F; -on tile[0]: clock pdmclk = XS1_CLKBLK_1; - -out buffered port:32 p_i2s_dout[1] = on tile[1]: {XS1_PORT_1P}; -in port p_mclk_in1 = on tile[1]: XS1_PORT_1O; -out buffered port:32 p_bclk = on tile[1]: XS1_PORT_1M; -out buffered port:32 p_lrclk = on tile[1]: XS1_PORT_1N; -out port p_pll_sync = on tile[1]: XS1_PORT_4D; -port p_i2c = on tile[1]: XS1_PORT_4E; // Bit 0: SCLK, Bit 1: SDA -port p_rst_shared = on tile[1]: XS1_PORT_4F; // Bit 0: DAC_RST_N, Bit 1: ETH_RST_N -clock mclk = on tile[1]: XS1_CLKBLK_3; -clock bclk = on tile[1]: XS1_CLKBLK_4; - -int data_0[4*THIRD_STAGE_COEFS_PER_STAGE*DF] = {0}; -int data_1[4*THIRD_STAGE_COEFS_PER_STAGE*DF] = {0}; - -void test_output(streaming chanend c_ds_output[2], - client interface mabs_led_button_if lb, chanend c_audio){ - - mic_array_frame_time_domain audio[2]; - - printf("Output test started\n"); - unsafe{ - unsigned buffer; //buffer index - memset(audio, sizeof(mic_array_frame_time_domain), 0); - - unsigned gain = 8; - - mic_array_decimator_conf_common_t dcc = {MIC_ARRAY_MAX_FRAME_SIZE_LOG2, 1, 0, 0, DF, - g_third_stage_div_2_fir, 0, FIR_COMPENSATOR_DIV_2, - DECIMATOR_NO_FRAME_OVERLAP, 2}; - mic_array_decimator_config_t dc[2] = { - {&dcc, data_0, {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0}, - {&dcc, data_1, {INT_MAX, INT_MAX, INT_MAX, INT_MAX}, 4, 0} - }; - mic_array_decimator_configure(c_ds_output, 2, dc); - - mic_array_init_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - - unsigned c=0; - timer t; - unsigned now, then; - mic_array_get_next_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - t :> then; -#define SAMPLES 0x3fff - for(unsigned i=0;i now; - printf("Sample rate of the microphone output: %f\n",((float)SAMPLES*100000000.0)/(float)(now- then)); - - while(1){ - mic_array_frame_time_domain * current = mic_array_get_next_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - select { - case lb.button_event():{ - unsigned button; - mabs_button_state_t pressed; - lb.get_button_event(button, pressed); - if(pressed == BUTTON_PRESSED){ - switch(button){ - case 0: - case 1:{ - gain++; - printf("gain: %d\n", gain); - break; - } - case 2: - case 3:{ - gain--; - printf("gain: %d\n", gain); - break; - } - } - } - break; - } - default:break; - } - - for(int j=0;j<1<data[0][j]; - output *= gain; - c_audio <: output; - c_audio <: output; - - for(unsigned i=0;i<8;i++){ - xscope_int(i, current->data[i][j]); - } - - } - } - } -} - -#define OUTPUT_SAMPLE_RATE (96000/DF) -#define MASTER_CLOCK_FREQUENCY 24576000 -[[distributable]] -void i2s_handler(server i2s_callback_if i2s, - client i2c_master_if i2c, chanend c_audio){ - p_rst_shared <: 0xF; - - mabs_init_pll(i2c, ETH_MIC_ARRAY); - - i2c_regop_res_t res; - int i = 0x4A; - uint8_t data = i2c.read_reg(i, 1, res); - - data = i2c.read_reg(i, 0x02, res); - data |= 1; - res = i2c.write_reg(i, 0x02, data); // Power down - - // Setting MCLKDIV2 high if using 24.576MHz. - data = i2c.read_reg(i, 0x03, res); - data |= 1; - res = i2c.write_reg(i, 0x03, data); - - data = 0b01110000; - res = i2c.write_reg(i, 0x10, data); - - data = i2c.read_reg(i, 0x02, res); - data &= ~1; - res = i2c.write_reg(i, 0x02, data); // Power up - - timer t; - unsigned now, then; - t:> then; - - unsigned count = 0; - while (1) { - select { - case i2s.init(i2s_config_t &?i2s_config, tdm_config_t &?tdm_config): - /* Configure the I2S bus */ - i2s_config.mode = I2S_MODE_LEFT_JUSTIFIED; - i2s_config.mclk_bclk_ratio = (MASTER_CLOCK_FREQUENCY/OUTPUT_SAMPLE_RATE)/64; - break; - case i2s.restart_check() -> i2s_restart_t restart: - restart = I2S_NO_RESTART; - break; - case i2s.receive(size_t index, int32_t sample): - break; - case i2s.send(size_t index) -> int32_t sample: - - if(count < SAMPLES){ - count++; - if(count == SAMPLES){ - t:> now; - printf("Sample rate of the i2s output: %f\n",((float)SAMPLES*100000000.0/2.0)/(float)(now- then)); - } - } else { - c_audio:> sample; - } - break; - } - } -} - - -void test_pdm_clock(){ - unsigned time, now, then; - timer t; - t :> time; - t:> then; - int testing_mclk = 1; - p_pdm_mics:> int; - #define CLOCK_COUNT 1000000 - while(testing_mclk){ - select { - case t when timerafter(time + 100000000):> time:{ - printf("Time out on PDM clock\n"); - testing_mclk = 0; - break; - } - case p_pdm_mics:> int:{ - testing_mclk++; - t :> time; - if(testing_mclk == CLOCK_COUNT){ - printf("PDM clock present: "); - t:> now; - unsigned elapsed = (now - then); - float t = (CLOCK_COUNT)/ (((float)elapsed*2)*10.0) * 1000.0; - printf("%fMHz\n", t); - testing_mclk = 0; - } - break; - } - } - } -} - -void sine_gen(streaming chanend c_sine){ -#define SINE_FREQ 1000 -#define LUT_SIZE (OUTPUT_SAMPLE_RATE / SINE_FREQ) - - int sine[LUT_SIZE]; - for(unsigned i=0;i - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - xmake - CONFIG=Default - all - true - true - true - - - xmake - CONFIG=Default - clean - true - true - true - - - - - diff --git a/legacy_tests/test_pdm_interface/.project b/legacy_tests/test_pdm_interface/.project deleted file mode 100644 index 2b39bdd3..00000000 --- a/legacy_tests/test_pdm_interface/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - test_pdm_interface - - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/legacy_tests/test_pdm_interface/Makefile b/legacy_tests/test_pdm_interface/Makefile deleted file mode 100644 index 759d2770..00000000 --- a/legacy_tests/test_pdm_interface/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = test_pdm_interface - -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -# You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS -# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to -# xcc for the final link (mapping) stage. -COMMON_FLAGS = -O2 -g -Wno-timing -DTEST_MODE - -XCC_FLAGS_CH4 = $(COMMON_FLAGS) -DCHANNELS=4 -XCC_FLAGS_CH8 = $(COMMON_FLAGS) -DCHANNELS=8 - -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/legacy_tests/test_pdm_interface/config.xscope b/legacy_tests/test_pdm_interface/config.xscope deleted file mode 100644 index bfdf1f86..00000000 --- a/legacy_tests/test_pdm_interface/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/legacy_tests/test_pdm_interface/src/mic_array_conf.h b/legacy_tests/test_pdm_interface/src/mic_array_conf.h deleted file mode 100644 index 6ed389be..00000000 --- a/legacy_tests/test_pdm_interface/src/mic_array_conf.h +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_NUM_MICS 8 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/legacy_tests/test_pdm_interface/src/test_pdm_interface.xc b/legacy_tests/test_pdm_interface/src/test_pdm_interface.xc deleted file mode 100644 index 9973d308..00000000 --- a/legacy_tests/test_pdm_interface/src/test_pdm_interface.xc +++ /dev/null @@ -1,210 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "mic_array.h" -#include -#include -#include - -extern void pdm_rx_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -void test8ch(){ - - streaming chan c, d, c_port; - par { - pdm_rx_debug(c_port, c, d); - { - for(unsigned ch=0;ch<8;ch++){ - for(unsigned i=0;i<12;i++) c_port <: 0x00000000; - - unsigned mask = 1< vals[i*2]; - d :> vals[i*2+1]; - } - - for(unsigned j=0;j<5;j++){ - for(unsigned i=0;i<4;i++){ - int v; - c :> v; - if (v!= vals[i*2]) - printf("Error: channels are not the same\n"); - d :> v; - if (v!= vals[i*2+1]) - printf("Error: channels are not the same\n"); - } - } - unsigned m = ch_to_mic[ch]; - min_sat = vals[m]; - //then test each channel - - for(unsigned o=0;o<8;o++){ - for(unsigned s=0;s<6;s++){ - for(unsigned i=0;i<4;i++){ - c :> vals[i*2]; - d :> vals[i*2+1]; - } - for(unsigned i=0;i<8;i++){ - if(m == i){ - unsigned index = (7-o + s*8); - int d = (vals[i] - min_sat)/2 - fir1_debug[index]; - if(d*d>1) - printf("Error: unexpected coefficient\n"); - } else { - if((vals[i] - min_sat) != 0) - printf("Error: crosstalk detected\n"); - } - } - } - } - } - printf("Success!\n"); - _Exit(0); - } - } -} -void test4ch(){ - - streaming chan c, c_port; - par { - pdm_rx_debug(c_port, c, null); - { - for(unsigned ch=0;ch<8;ch++){ - for(unsigned i=0;i<12;i++) c_port <: 0x00000000; - - unsigned mask = 1< vals[i]; - } - - for(unsigned j=0;j<5;j++){ - for(unsigned i=0;i<4;i++){ - int v; - c :> v; - if (v!= vals[i]) - printf("Error: channels are not the same\n"); - } - } - unsigned m = ch_to_mic[ch]; - min_sat = vals[m]; - //then test each channel - - for(unsigned o=0;o<8;o++){ - for(unsigned s=0;s<6;s++){ - for(unsigned i=0;i<4;i++) - c :> vals[i]; - for(unsigned i=0;i<4;i++){ - if(m == i){ - unsigned index = (7-o + s*8); - int d = (vals[i] - min_sat)/2 - fir1_debug[index]; - if(d*d>1) - printf("Error: unexpected coefficient\n"); - } else { - if((vals[i] - min_sat) != 0) - printf("Error: crosstalk detected\n"); - } - } - } - } - } - printf("Success!\n"); - _Exit(0); - } - } -} - -int main(){ - -#if CHANNELS == 4 - test4ch(); -#else - test8ch(); -#endif - return 0; -} diff --git a/legacy_tests/test_pdm_interface/wscript b/legacy_tests/test_pdm_interface/wscript deleted file mode 100644 index 5429161a..00000000 --- a/legacy_tests/test_pdm_interface/wscript +++ /dev/null @@ -1,71 +0,0 @@ -import os -from waflib import Options, Errors -from waflib.Build import BuildContext, CleanContext - -CONFIGS = [ - 'CH4', - 'CH8', -] - -def create_waf_contexts(configs): - for test_name in configs: - for ctx in (BuildContext, CleanContext): - raw_context = ctx.__name__.replace('Context', '').lower() - - class tmp(ctx): - cmd = raw_context + '_' + test_name - variant = test_name - variant = os.path.split(os.getcwd())[1] + '_' + variant - -create_waf_contexts(CONFIGS) - -def options(opt): - opt.add_option('--config', action='store', - help='Choose among the supported configurations') - opt.load('xwaf.xcommon') - - -def configure(conf): - conf.load('xwaf.compiler_xcc') - - -def build(bld): - - if not bld.variant: - build_configs = [] - try: - build_configs = [ - c for c in CONFIGS if c == bld.options.config - ] - except AttributeError: - pass - - if len(build_configs) == 0: - bld.fatal('specify a config with --config.\nAvailable configs: {}'.format(', '.join(CONFIGS))) - return - - build_commands = ['{}_{}'.format(bld.cmd, c) for c in build_configs] - print("build_commands = {}".format(build_commands)) - - if not build_commands: - bld.fatal/( - '{} does not match any configs'.format(bld.options.config)) - - cmd_str = {'build': 'Building', 'clean': 'Cleaning', 'list': "Listing"}[bld.cmd] - print('{} configs:\n {}'.format(cmd_str, '\n '.join( - build_configs))) - if not bld.cmd == 'list': - Options.commands = build_commands + Options.commands - return - - bld.do_xcommon() - - - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/lib_mic_array/.cproject b/lib_mic_array/.cproject deleted file mode 100644 index bf7d7c11..00000000 --- a/lib_mic_array/.cproject +++ /dev/null @@ -1,933 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/lib_mic_array/.makefile b/lib_mic_array/.makefile deleted file mode 100644 index 16eb7795..00000000 --- a/lib_mic_array/.makefile +++ /dev/null @@ -1,4 +0,0 @@ -all: - @echo "** Module only - only builds as part of application **" -clean: - @echo "** Module only - only builds as part of application **" diff --git a/lib_mic_array/.project b/lib_mic_array/.project deleted file mode 100644 index de1c4d61..00000000 --- a/lib_mic_array/.project +++ /dev/null @@ -1,42 +0,0 @@ - - - lib_mic_array - - - - - - com.xmos.cdt.core.LegacyProjectCheckerBuilder - - - - - com.xmos.cdt.core.ProjectInfoSyncBuilder - - - - - com.xmos.cdt.core.ModulePathBuilder - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - com.xmos.cdt.core.XdeProjectNature - - diff --git a/lib_mic_array/CMakeLists.txt b/lib_mic_array/CMakeLists.txt new file mode 100644 index 00000000..e398c938 --- /dev/null +++ b/lib_mic_array/CMakeLists.txt @@ -0,0 +1,53 @@ +set(MIC_ARRAY_PATH ${CMAKE_CURRENT_LIST_DIR}) + +## Source files +file( GLOB_RECURSE MIC_ARRAY_C_SOURCES ${MIC_ARRAY_PATH}/src/*.c ) +file( GLOB_RECURSE MIC_ARRAY_XC_SOURCES ${MIC_ARRAY_PATH}/src/*.xc ) +file( GLOB_RECURSE MIC_ARRAY_CPP_SOURCES ${MIC_ARRAY_PATH}/src/*.cpp ) +file( GLOB_RECURSE MIC_ARRAY_ASM_SOURCES ${MIC_ARRAY_PATH}/src/*.S ) + +## Compile flags +unset(MIC_ARRAY_COMPILE_FLAGS) +list( APPEND MIC_ARRAY_COMPILE_FLAGS + -Wno-unused-variable + -Wno-missing-braces + -Wno-xcore-fptrgroup + -O2 +) + +# Includes +set( MIC_ARRAY_INCLUDES ${MIC_ARRAY_PATH}/api ) + +unset(MIC_ARRAY_SOURCES) +list( APPEND MIC_ARRAY_SOURCES ${MIC_ARRAY_C_SOURCES} + ${MIC_ARRAY_XC_SOURCES} + ${MIC_ARRAY_CPP_SOURCES} + ${MIC_ARRAY_ASM_SOURCES} ) + +set_source_files_properties( ${MIC_ARRAY_XC_SOURCES} PROPERTIES LANGUAGE C ) + +## Apply compile flags +foreach(COMPILE_FLAG ${MIC_ARRAY_COMPILE_FLAGS}) + set_source_files_properties( ${MIC_ARRAY_SOURCES} + PROPERTIES COMPILE_FLAGS ${COMPILE_FLAG}) +endforeach() + + +add_library(lib_mic_array STATIC) + +target_sources(lib_mic_array + PRIVATE ${MIC_ARRAY_SOURCES} +) + +target_include_directories(lib_mic_array + PUBLIC ${MIC_ARRAY_INCLUDES} +) + +target_compile_options(lib_mic_array + PRIVATE ${MIC_ARRAY_COMPILE_FLAGS} +) + +target_link_libraries(lib_mic_array + PUBLIC + lib_xcore_math +) diff --git a/lib_mic_array/api/mic_array.h b/lib_mic_array/api/mic_array.h index 8d3ebca3..7cdc4c00 100644 --- a/lib_mic_array/api/mic_array.h +++ b/lib_mic_array/api/mic_array.h @@ -1,319 +1,18 @@ -// Copyright 2015-2021 XMOS LIMITED. +// Copyright 2015-2022 XMOS LIMITED. // This Software is subject to the terms of the XMOS Public Licence: Version 1. -#if __XC__ -#ifndef MIC_ARRAY_H_ -#define MIC_ARRAY_H_ - -#include -#include -#include "fir_coefs.h" -#include "mic_array_frame.h" - -#ifndef MIC_ARRAY_HIRES_MAX_DELAY - #define MIC_ARRAY_HIRES_MAX_DELAY 256 -#endif - -#define MIC_ARRAY_NO_INTERNAL_CHANS (0) - - -/** PDM Microphone Interface component. - * - * This task handles the interface to up to 8 PDM microphones whilst also decimating - * the PDM data by a factor of 8. The output is sent via two channels to two receiving - * tasks. - * - * \param p_pdm_mics The 8 bit wide port connected to the PDM microphones. - * \param c_4x_pdm_mic_0 The channel where the decimated PDM of microphones 0-3 will - * be outputted. - * \param c_4x_pdm_mic_1 The channel where the decimated PDM of microphones 4-7 will - * be outputted. This can be null for 4 channel output. - */ -void mic_array_pdm_rx( - in buffered port:32 p_pdm_mics, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -void mic_dual_pdm_rx_decimate( - in buffered port:32 p_pdm_mics, - streaming chanend c_2x_pdm_mic, - streaming chanend c_ref_audio[]); - - -/** High resolution delay component. - * - * This task handles the application of individual delays for up to 16 channels. - * Each unit of delay represents one sample at the input sample rate, i.e. the rate - * at which the circular buffer is being updated. The maximum delay is given by the - * size of the circular buffer. - * - * \param c_from_pdm_frontend The channels connecting to the output of the PDM interface - * \param c_to_decimator The channels connecting to the input of the 4 channel decimators. - * \param n The size of the two channel arrays, they must be the same. - * \param c_cmd The channel connecting the application to this task used for - * setting the delays. - */ -void mic_array_hires_delay( - streaming chanend c_from_pdm_frontend[], - streaming chanend c_to_decimator[], - unsigned n, - streaming chanend c_cmd); - -/** Application side interface to high resolution delay. - * - * This function is used by the client of the high resolution delay to set the delays. - * - * \param c_cmd The channel connecting the application to this task used for - * setting the delays. - * \param delays An array of the delays to be set. These must all be less than MIC_ARRAY_HIRES_MAX_DELAY. - * \param num_channels The number of microphones. This must be the same as the delays array. - */ -void mic_array_hires_delay_set_taps(streaming chanend c_cmd, unsigned delays[], unsigned num_channels); - -/** Four Channel decimator buffering type. - * - * This type is used to describe the buffering mode. Note: to use a windowing function the constant-overlap-and-add property - * must be obeyed, i.e. Coef[n] = 1-Coef[N-n] where N is the array length. Only half the array need be - * specified as the windowing function is assumed to be symmetric. - */ -typedef enum { - DECIMATOR_NO_FRAME_OVERLAP, ///< The frames have no overlap. - DECIMATOR_HALF_FRAME_OVERLAP ///< The frames have a 50% overlap betweeen sequential frames. -} mic_array_decimator_buffering_t; - -/** Four Channel decimator configuration structure. - * - * This is used to describe the configuration that the group of synchronous decimators will use to process the PCM audio. - */ -typedef struct { - - unsigned len; /**< If len is less than 16 then this sets the frame size to 2 to the power of len, i.e. A frame will contain 2 to the power of len samples of each channel. - If len is 16 or greater then the frame size is equal to len. */ - - int apply_dc_offset_removal; /**< Remove the DC offset from the audio before the final decimation. Set to non-zero to enable. */ - - int index_bit_reversal; /**< If non-zero then bit reverse the index of the elements within the frame. Used in the case of preparing for an FFT.*/ - - int * unsafe windowing_function; /**< If non-null then this will apply a windowing function to the frame. Used in the case of preparing for an FFT. */ - - unsigned output_decimation_factor; /**< Final stage FIR Decimation factor. */ - - const int * unsafe coefs; /**< The coefficients for the FIR decimator. */ - - int apply_mic_gain_compensation; /**< Set to non-zero to apply microphone gain compensation. */ - - int fir_gain_compensation; /**< 5.27 format for the gain compensation for the three stages of FIR filter. */ - - mic_array_decimator_buffering_t buffering_type; /**< The buffering type used for frame exchange. */ - - unsigned number_of_frame_buffers; /**< The count of frames used between the decimators and the application. */ - -} mic_array_decimator_conf_common_t; - -/** Configuration structure unique to each of the 4 channel deciamtors. - * - * This contains configuration that is channel specific, i.e. Gain compensation, etc. - */ -typedef struct { - - mic_array_decimator_conf_common_t * unsafe dcc; - - int * unsafe data; /**< The data for the FIR decimator */ - - int mic_gain_compensation[4]; /**< An array describing the relative gain compensation to apply to the microphones. The microphone with the least gain is defined as 0x7fffffff (INT_MAX), all others are given as INT_MAX*min_gain/current_mic_gain.*/ - - unsigned channel_count; /**< The count of enabled channels (0->4). */ - - - unsigned async_interface_enabled; /** If set to 1, this disables the mic_array_get_next_time_domain_frame interface - and enables the mic_array_recv_sample interface. **/ - - -} mic_array_decimator_config_t; - -typedef unsigned mic_array_internal_audio_channels; - -/** Four Channel Decimation component. - * - * This task decimates the four channel input down to the desired output sample rate. - * The decimator has a fixed divide by 4 followed by a divide by decimation_factor where - * decimation_factor is greater than or equal to 2. - * The channel c_frame_output is used to transfer data and control information between the - * application and this task. It relies of shared memory for so the client of this task must - * be on the same tile as this task. - * - * \param c_from_pdm_interface The channel where the decimated PDM from pdm_rx task will be inputted. - * \param c_frame_output The channel used to transfer data and control information between - * the client of this task and this task. - * \param channels A pointer to an array of mic_array_internal_audio_channels. This can be set to - * MIC_ARRAY_NO_INTERNAL_CHANS if none are requires. - */ -void mic_array_decimate_to_pcm_4ch( - streaming chanend c_from_pdm_interface, - streaming chanend c_frame_output, mic_array_internal_audio_channels * channels); - -/** Far end channel connector. - * - * This function allowed a connection to be established between a signal producer and the microphone - * array. The sample rate of the producer and sample rate of the output of the microphone array must - * match. - * - * \param internal_channels An array of mic_array_internal_audio_channels. - * MIC_ARRAY_NO_INTERNAL_CHANS if none are requires. - * \param ch0 The channel used to send internal audio to mic_array - * channel 0. - * \param ch1 The channel used to send internal audio to mic_array - * channel 1. - * \param ch2 The channel used to send internal audio to mic_array - * channel 2. - * \param ch3 The channel used to send internal audio to mic_array - * channel 3. - */ -void mic_array_init_far_end_channels(mic_array_internal_audio_channels internal_channels[4], - streaming chanend ?ch0, streaming chanend ?ch1, - streaming chanend ?ch2, streaming chanend ?ch3); - -/** This sends an audio sample to a decimator. - * - * This function call sets up the four channel decimators. After this has been called there - * will be a real time requirement on this task, i.e. this task must call - * mic_array_get_next_time_domain_frame() at the output sample rate multiplied by the frame size. - * - * \param c_to_decimator The channel used to transfer audio sample beterrn the application and - * the decimators. - * \param sample The audio sample to be transfered. - * \returns 0 for success and 1 for failure. Failure may occour when the decimators - * are not yet running. - * - */ -int mic_array_send_sample( streaming chanend c_to_decimator, int sample); - -/** This receives a pair of audio samples from a decimator. async_interface_enabled - * must be set in the decimator config for this function to work as intended. - * - * If this function isn't called at least at the rate at which the decimator is outputting samples - * it will cause timing related errors. - * - * \param c_from_decimator The channel used to transfer audio sample between - * the decimator and the application. - * \param ch_a The first audio sample to be received. - * \param ch_b The second audio sample to be received. - * \returns 0 for success and 1 for failure. Failure may occur when the decimators - * are not yet running or when a new sample isn't ready. - * - */ -int mic_array_recv_samples(streaming chanend c_from_decimator, int &ch_a, int &ch_b); - - -/** Four Channel Decimation initializer for raw audio frames. - * - * This function call sets up the four channel decimators. After this has been called there - * will be a real time requirement on this task, i.e. this task must call - * mic_array_get_next_time_domain_frame() at the output sample rate multiplied by the frame size. - * - * \param c_from_decimators The channels used to transfer pointers between the application and - * the mic_array_decimate_to_pcm_4ch() tasks. - * \param decimator_count The count of mic_array_decimate_to_pcm_4ch() tasks. - * \param buffer The buffer index. Always points to the index that is accessible to - * the application (initialized internally) - * \param audio An array of audio frames. - * \param dc The array cointaining the decimator configuration for each decimator. - * - */ -void mic_array_init_time_domain_frame( - streaming chanend c_from_decimators[], unsigned decimator_count, - unsigned &buffer, mic_array_frame_time_domain audio[], - mic_array_decimator_config_t dc[]); - - -/** Four Channel Decimation raw audio frame exchange function. - * - * This function handles the frame exchange between the mic_array_decimate_to_pcm_4ch() tasks and the - * application. It returns a pointer to the most recently written frame. After this point the oldest - * frame is assumed out of scope to the application. - * Current behaviour: this function must be called before the decimators have produced the full frame - * and are ready for exachange. If this function is not called in time then the PDM data will be dropped - * until the frame is accepted from the decimators. Failure to meet timing can be detected by enabling - * DEBUG_MIC_ARRAY in your makefile with -DDEBUG_MIC_ARRAY. - * Future behaviour: if this function is not called before the frame has been produced by the decimators - * then the frame is dropped. This can be detected with the frame_counter attached to the metadata of the - * frame. Sequential frames will have frame_counters that increament by one. - * - * \param c_from_decimators The channels used to transfer pointers between the application and - * the mic_array_decimate_to_pcm_4ch() tasks. - * \param decimator_count The count of mic_array_decimate_to_pcm_4ch() tasks. - * \param buffer The buffer index (Used internally) - * \param audio An array of audio frames. - * \param dc The array cointaining the decimator configuration for each decimator. - * - * \returns A pointer to the frame now owned by the application. That is, the most - * recently written samples. - */ -mic_array_frame_time_domain * alias mic_array_get_next_time_domain_frame( - streaming chanend c_from_decimators[], unsigned decimator_count, - unsigned &buffer, mic_array_frame_time_domain * alias audio, - mic_array_decimator_config_t dc[]); - -/** Four Channel Decimation initializer for complex frames. - * - * This function call sets up the four channel decimators. After this has been called there - * will be a real time requirement on this task, i.e. this task must call - * mic_array_get_next_frequency_domain_frame() at the output sample rate multiplied by the frame size. - * - * \param c_from_decimators The channels used to transfer pointers between the application and - * the mic_array_decimate_to_pcm_4ch() tasks. - * \param decimator_count The count of mic_array_decimate_to_pcm_4ch() tasks. - * \param buffer The buffer index. Always points to the index that is accessible to - * the application (initialized internally) - * \param f_fft_preprocessed An array of complex frames. - * \param dc The array cointaining the decimator configuration for each decimator. - * - */ -void mic_array_init_frequency_domain_frame(streaming chanend c_from_decimators[], unsigned decimator_count, - unsigned &buffer, mic_array_frame_fft_preprocessed f_fft_preprocessed[], mic_array_decimator_config_t dc[]); - -/** Four Channel Decimation complex frame exchange function. - * - * This function handles the frame exchange between the mic_array_decimate_to_pcm_4ch() tasks and the - * application. It returns a pointer to the most recently written frame. After this point the oldest - * frame is assumed out of scope to the application. - * Current behaviour: this function must be called before the decimators have produced the full frame - * and are ready for exachange. If this function is not called in time then the PDM data will be dropped - * until the frame is accepted from the decimators. Failure to meet timing can be detected by enabling - * DEBUG_MIC_ARRAY in your makefile with -DDEBUG_MIC_ARRAY. - * Future behaviour: if this function is not called before the frame has been produced by the decimators - * then the frame is dropped. This can be detected with the frame_counter attached to the metadata of the - * frame. Sequential frames will have frame_counters that increament by one. - * - * \param c_from_decimators The channels used to transfer pointers between the application and - * the mic_array_decimate_to_pcm_4ch() tasks. - * \param decimator_count The count of mic_array_decimate_to_pcm_4ch() tasks. - * \param buffer The buffer index (Used internally) - * \param f_fft_preprocessed An array of complex frames. - * \param dc The array cointaining the decimator configuration for each decimator. - * - * \returns A pointer to the frame now owned by the application. That is, the most - * recently written samples. - */ -mic_array_frame_fft_preprocessed * alias mic_array_get_next_frequency_domain_frame( - streaming chanend c_from_decimators[], unsigned decimator_count, - unsigned &buffer, mic_array_frame_fft_preprocessed * alias f_fft_preprocessed, - mic_array_decimator_config_t dc[]); - - -/** Decimator configuration - * - * This function initializes the decimators and configures them as per the decimator configuration - * structure thay are passed. - * - * \param c_from_decimators The channels used to transfer pointers between the application and - * the mic_array_decimate_to_pcm_4ch() task. - * \param decimator_count The count of mic_array_decimate_to_pcm_4ch() tasks. - * \param dc The array cointaining the decimator configuration for each decimator. - */ -void mic_array_decimator_configure( - streaming chanend c_from_decimators[], - unsigned decimator_count, - mic_array_decimator_config_t dc[]); - -#endif /* MIC_ARRAY_H_ */ -#endif +#pragma once + +#include "mic_array/api.h" +#include "mic_array/pdm_resources.h" +#include "mic_array/dc_elimination.h" +#include "mic_array/frame_transfer.h" +#include "mic_array/setup.h" + +#ifdef __cplusplus +# include "mic_array/cpp/Decimator.hpp" +# include "mic_array/cpp/MicArray.hpp" +# include "mic_array/cpp/OutputHandler.hpp" +# include "mic_array/cpp/PdmRx.hpp" +# include "mic_array/cpp/Prefab.hpp" +# include "mic_array/cpp/SampleFilter.hpp" +#endif \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/api.h b/lib_mic_array/api/mic_array/api.h new file mode 100644 index 00000000..2d585937 --- /dev/null +++ b/lib_mic_array/api/mic_array/api.h @@ -0,0 +1,50 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + + +#if defined(__cplusplus) +# define FROM_C 0 +# define FROM_CPP 1 +# define FROM_XC 0 +#elif defined(__XC__) +# define FROM_C 0 +# define FROM_CPP 0 +# define FROM_XC 1 +#else //no explicit definitions for C files +# define FROM_C 1 +# define FROM_CPP 0 +# define FROM_XC 0 +#endif + +// I'd rather call this `C_API`, but there's currently an issue in lib_xs3_math +// where it defines `C_API` without checking whether it's already defined. That +// creates problems depending on the order in which headers are included. +#ifndef MA_C_API +// XC doesn't support marking individual functions as 'extern "C"`. It requires +// use of the block notation. +# if FROM_C || FROM_XC +# define MA_C_API +# else +# define MA_C_API extern "C" +# endif +#endif + + +#ifndef C_API_START +# if FROM_XC +# define C_API_START extern "C" { +# else +# define C_API_START +# endif +#endif + + +#ifndef C_API_END +# if FROM_XC +# define C_API_END } +# else +# define C_API_END +# endif +#endif \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/cpp/Decimator.hpp b/lib_mic_array/api/mic_array/cpp/Decimator.hpp new file mode 100644 index 00000000..bfb46407 --- /dev/null +++ b/lib_mic_array/api/mic_array/cpp/Decimator.hpp @@ -0,0 +1,257 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include +#include +#include + +#include "xmath/xmath.h" +#include "mic_array/etc/fir_1x16_bit.h" + +// This has caused problems previously, so just catch the problems here. +#if defined(MIC_COUNT) || defined(S2_DEC_FACTOR) || defined(S2_TAP_COUNT) +# error Application must not define the following as precompiler macros: MIC_COUNT, S2_DEC_FACTOR, S2_TAP_COUNT. +#endif + + +namespace mic_array { + +/** + * @brief Rotate 8-word buffer 1 word up. + * + * Each word `buff[k]` is moved to `buff[(k+1)%8]`. + * + * @param buff Word buffer to be rotated. + */ +static inline +void shift_buffer(uint32_t* buff); + + +/** + * @brief First and Second Stage Decimator + * + * This class template represents a two stage decimator which converts a stream + * of PDM samples to a lower sample rate stream of PCM samples. + * + * Concrete implementations of this class template are meant to be used as the + * `TDecimator` template parameter in the @ref MicArray class template. + * + * @tparam MIC_COUNT Number of microphone channels. + * @tparam S2_DEC_FACTOR Stage 2 decimation factor. + * @tparam S2_TAP_COUNT Stage 2 tap count. + */ +template +class TwoStageDecimator +{ + + public: + /** + * Size of a block of PDM data in words. + */ + static constexpr unsigned BLOCK_SIZE = MIC_COUNT * S2_DEC_FACTOR; + + /** + * Number of microphone channels. + */ + static constexpr unsigned MicCount = MIC_COUNT; + + /** + * Stage 2 decimator parameters + */ + static const struct { + /** + * Stage 2 decimator decimation factor. + */ + unsigned DecimationFactor = S2_DEC_FACTOR; + /** + * Stage 2 decimator tap count. + */ + unsigned TapCount = S2_TAP_COUNT; + } Stage2; + + private: + + /** + * Stage 1 decimator configuration and state. + */ + struct { + /** + * Pointer to filter coefficients for Stage 1 + */ + const uint32_t* filter_coef; + /** + * Filter state (PDM history) for stage 1 filters. + */ + uint32_t pdm_history[MIC_COUNT][8] +#ifndef __DOXYGEN__ // doxygen breaks if it encounters this. + // Must be initialized in this way. Initializing the history values in the + // constructor causes an XCore-specific problem. Specifically, if the + // MicArray instance where this decimator is used is declared outside of a + // function scope (that is, as a global- or module-scope object; which it + // ordinarily will be), initializing the PDM history within the + // constructor forces the compiler to allocate the object on _all tiles_. + // Being allocated on a tile where it is not used does not by itself break + // anything, but it does result in less memory being available for other + // things on that tile. Initializing the history in this way prevents + // that. + = {[0 ... (MIC_COUNT-1)] = { [0 ... 7] = 0x55555555 } } +#endif + ; + } stage1; + + /** + * Stage 2 decimation configuration and state. + */ + struct { + /** + * Stage 2 FIR filters + */ + filter_fir_s32_t filters[MIC_COUNT]; + /** + * Stage 2 filter stage. + */ + int32_t filter_state[MIC_COUNT][S2_TAP_COUNT] = {{0}}; + } stage2; + + public: + + constexpr TwoStageDecimator() noexcept { } + + /** + * @brief Initialize the decimator. + * + * Sets the stage 1 and 2 filter coefficients. The decimator must be + * initialized before any calls to `ProcessBlock()`. + * + * `s1_filter_coef` points to a block of coefficients for the first stage + * decimator. This library provides coefficients for the first stage + * decimator; see `mic_array/etc/filters_default.h`. + * + * `s2_filter_coef` points to an array of coefficients for the second stage + * decimator. This library provides coefficients for the second stage + * decimator where the second stage decimation factor is 6; see + * `mic_array/etc/filters_default.h`. + * + * `s2_filter_shr` is the final right-shift applied to the stage 2 filter's + * accumulator prior to output. See + * lib_xcore_math's + * documentation of `filter_fir_s32_t` for more details. + * + * @param s1_filter_coef @parblock + * Stage 1 filter coefficients. + * + * This points to a block of coefficients for the first stage + * decimator. This library provides coefficients for the first stage + * decimator. \verbatim embed:rst + See :c:var:`stage1_coef`.\endverbatim + * @endparblock + * @param s2_filter_coef @parblock + * Stage 2 filter coefficients. + * + * This points to a block of coefficients for the second stage + * decimator. This library provides coefficients for the second stage + * decimator. \verbatim embed:rst + See :c:var:`stage2_coef`.\endverbatim + * @endparblock + * @param s2_filter_shr @parblock + * Stage 2 filter right-shift. + * + * This is the output shift used by the second stage decimator. + * \verbatim embed:rst + See :c:var:`stage2_shr`.\endverbatim + * @endparblock + */ + void Init( + const uint32_t* s1_filter_coef, + const int32_t* s2_filter_coef, + const right_shift_t s2_filter_shr); + + /** + * @brief Process one block of PDM data. + * + * Processes a block of PDM data to produce an output sample from the + * second stage decimator. + * + * `pdm_block` contains exactly enough PDM samples to produce a single + * output sample from the second stage decimator. The layout of `pdm_block` + * should (effectively) be: + * + * @code{.cpp} + * struct { + * struct { + * // lower word indices are older samples. + * // less significant bits in a word are older samples. + * uint32_t samples[S2_DEC_FACTOR]; + * } microphone[MIC_COUNT]; // mic channels are in ascending order + * } pdm_block; + * @endcode + * + * A single output sample from the second stage decimator is computed and + * written to `sample_out[]`. + * + * @param sample_out Output sample vector. + * @param pdm_block PDM data to be processed. + */ + void ProcessBlock( + int32_t sample_out[MIC_COUNT], + uint32_t pdm_block[BLOCK_SIZE]); + }; +} + +////////////////////////////////////////////// +// Template function implementations below. // +////////////////////////////////////////////// + + +template +void mic_array::TwoStageDecimator::Init( + const uint32_t* s1_filter_coef, + const int32_t* s2_filter_coef, + const right_shift_t s2_shr) +{ + this->stage1.filter_coef = s1_filter_coef; + + for(int k = 0; k < MIC_COUNT; k++){ + filter_fir_s32_init(&this->stage2.filters[k], &this->stage2.filter_state[k][0], + S2_TAP_COUNT, s2_filter_coef, s2_shr); + } +} + + + +template +void mic_array::TwoStageDecimator + ::ProcessBlock( + int32_t sample_out[MIC_COUNT], + uint32_t pdm_block[BLOCK_SIZE]) +{ + uint32_t (*pdm_data)[S2_DEC_FACTOR] = (uint32_t (*)[S2_DEC_FACTOR]) pdm_block; + + for(unsigned mic = 0; mic < MIC_COUNT; mic++){ + uint32_t* hist = &this->stage1.pdm_history[mic][0]; + + for(unsigned k = 0; k < S2_DEC_FACTOR; k++){ + hist[0] = pdm_data[mic][k]; + int32_t streamA_sample = fir_1x16_bit(hist, this->stage1.filter_coef); + shift_buffer(hist); + + if(k < (S2_DEC_FACTOR-1)){ + filter_fir_s32_add_sample(&this->stage2.filters[mic], streamA_sample); + } else { + sample_out[mic] = filter_fir_s32(&this->stage2.filters[mic], streamA_sample); + } + } + } +} + + +static inline +void mic_array::shift_buffer(uint32_t* buff) +{ + uint32_t* src = &buff[-1]; + asm volatile("vldd %0[0]; vstd %1[0];" :: "r"(src), "r"(buff) : "memory" ); +} + + diff --git a/lib_mic_array/api/mic_array/cpp/MicArray.hpp b/lib_mic_array/api/mic_array/cpp/MicArray.hpp new file mode 100644 index 00000000..3ce7613e --- /dev/null +++ b/lib_mic_array/api/mic_array/cpp/MicArray.hpp @@ -0,0 +1,265 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "PdmRx.hpp" +#include "Decimator.hpp" +#include "SampleFilter.hpp" +#include "OutputHandler.hpp" + +#include "mic_array.h" + +#include + +using namespace std; + +// This has caused problems previously, so just catch the problems here. +#if defined(MIC_COUNT) +# error Application must not define the following as precompiler macros: MIC_COUNT. +#endif + + +namespace mic_array { + + /** + * @brief Represents the microphone array component of an application. + * + * \verbatim embed:rst + Like many classes in this library, `FrameOutputHandler` uses the :ref:`crtp`.\endverbatim + * + * @tparam MIC_COUNT @parblock + * The number of microphones to be *captured* by the `MicArray`'s `PdmRx` + * component. For example, if using a 4-bit port to capture 6 microphone + * channels in a DDR configuration (because there are no 3 or 6 pin ports) + * `MIC_COUNT` should be ``8``, because that's how many must be captured, + * even if two of them are stripped out before passing audio frames to + * subsequent application stages. + * @endparblock + * + * @tparam TDecimator Type for the decimator. See @ref Decimator. + * @tparam TPdmRx Type for the PDM rx service used. See @ref PdmRx. + * @tparam TSampleFilter Type for the output filter used. See @ref SampleFilter. + * @tparam TOutputHandler Type for the output handler used. See @ref OutputHandler. + * + */ + template + class MicArray + { + + public: + + /** + * @brief Number of microphone channels. + */ + static constexpr unsigned MicCount = MIC_COUNT; + + + /** + * @brief The PDM rx service. + * + * The template parameter `TPdmRx` is the concrete class implementing the + * microphone array's PDM rx service, which is responsible for collecting + * PDM samples from a port and delivering them to the decimation thread. + * + * `TPdmRx` is only required to implement one function, `GetPdmBlock()`: + * @code {.cpp} + * uint32_t* GetPdmBlock(); + * @endcode + * + * `GetPdmBlock()` returns a pointer to a block of PDM data, formatted as + * expected by the decimator. `GetPdmBlock()` is called *from the + * decimator thread* and is expected to block until a new full block of + * PDM data is available to be decimated. + * + * For example, @ref StandardPdmRxService::GetPdmBlock() waits to receive + * a pointer to a block of PDM data from a streaming channel. The pointer + * is sent from the PdmRx interrupt (or thread) when the block has been + * completed. This is used for capturing PDM data from a port. + */ + TPdmRx PdmRx; + + /** + * @brief The Decimator. + * + * The template parameter `TDecimator` is the concrete class implementing + * the microphone array's decimation procedure. `TDecimator` is only + * required to implement one function, `ProcessBlock()`: + * @code{.cpp} + * void ProcessBlock( + * int32_t sample_out[MIC_COUNT], + * uint32_t pdm_block[BLOCK_SIZE]); + * @endcode + * + * `ProcessBlock()` takes a block of PDM samples via its `pdm_block` + * parameter, applies the appropriate decimation logic, and outputs a + * single (multi-channel) sample sample via its `sample_out` parameter. + * The size and formatting of the PDM block expected by the decimator + * depends on its particular implementation. + * + * A concrete class based on the @ref mic_array::TwoStageDecimator class + * template is used in the @ref prefab::BasicMicArray prefab. + */ + TDecimator Decimator; + + /** + * @brief The output filter. + * + * The template parameter `TSampleFilter` is the concrete class + * implementing the microphone array's sample filter component. This + * component can be used to apply additional non-decimating, + * non-interpolating filtering of samples. `TSampleFilter()` is only + * required to implement one function, `Filter()`: + * @code{.cpp} + * void Filter(int32_t sample[MIC_COUNT]); + * @endcode + * + * `Filter()` takes a single (multi-channel) sample from the decimator + * component's output and may update the sample in-place. + * + * For example a sample filter based on the @ref DcoeSampleFilter class + * template applies a simple first-order IIR filter to the output of the + * decimator, in order to elminate the DC component of the audio signals. + * + * If no additional filtering is required, the @ref NopSampleFilter class + * template can be used for `TSampleFilter`, which leaves the sample + * unmodified. In this case, it is expected that the call to + * @ref NopSampleFilter::Filter() will ultimately get completely + * eliminated at build time. That way no addition run-time compute or + * memory costs need be introduced for the additional flexibility. + * + * Even though `TDecimator` and `TSampleFilter` both (possibly) apply + * filtering, they are separate components of the `MicArray` because they + * are conceptually independent. + * + * A concrete class based on either the @ref DcoeSampleFilter class + * template or the @ref NopSampleFilter class template is used in the + * @ref prefab::BasicMicArray prefab, depending on the + * `USE_DCOE` parameter of that class template. + */ + TSampleFilter SampleFilter; + + /** + * @brief The output handler. + * + * The template parameter `TOutputHandler` is the concrete class + * implementing the microphone array's output handler component. After the + * PDM input stream has been decimated to the appropriate output sample + * rate, and after any post-processing of that output stream by the sample + * filter, the output samples must be delivered to another thread for any + * additional processing. It is the responsibility of this component to + * package and deliver audio samples to subsequent processing stages. + * + * `TOutputHandler` is only required to implement one function, + * `OutputSample()`: + * @code{.cpp} + * void OutputSample(int32_t sample[MIC_COUNT]); + * @endcode + * + * `OutputSample()` is called exactly once for each mic array output + * sample. `OutputSample()` may block if necessary until the subsequent + * processing stage ready to receive new data. However, the decimator + * thread (in which `OutputSample()` is called) as a whole has a real-time + * constraint - it must be ready to pull the next block of PDM data while + * it is available. + * + * A concrete class based on the @ref FrameOutputHandler class template is + * used in the @ref prefab::BasicMicArray prefab. + */ + TOutputHandler OutputHandler; + + public: + + /** + * @brief Construct a `MicArray`. + * + * This constructor uses the default constructor for each of its + * components, @ref PdmRx, @ref Decimator, @ref SampleFilter, + * and @ref OutputHandler. + */ + MicArray() { } + + /** + * @brief Construct a `MicArray`. + * + * This constructor uses the default constructor for its + * @ref Decimator component. + * + * The remaining components are initialized with the supplied objects. + * + * @param pdm_rx The PDM rx object. + * @param sample_filter The SampleFilter object. + * @param output_handler The OutputHandler object. + */ + MicArray(TPdmRx pdm_rx, + TSampleFilter sample_filter, + TOutputHandler output_handler) + : PdmRx(pdm_rx), + SampleFilter(sample_filter), + OutputHandler(output_handler) { } + + /** + * @brief Construct a `MicArray` + * + * This constructor uses the default constructor for its + * @ref Decimator and @ref SampleFilter components. + * + * The remaining components are initialized with the supplied objects. + * + * @param pdm_rx The PDM rx object. + * @param output_handler The OutputHandler object. + */ + MicArray(TPdmRx pdm_rx, + TOutputHandler output_handler) + : MicArray(pdm_rx, TSampleFilter(), output_handler) { } + + /** + * @brief Entry point for the decimation thread. + * + * This function does not return. It loops indefinitely, collecting blocks + * of PDM data from @ref PdmRx (which must have already been started), + * uses @ref Decimator to filter and decimate the sample stream to the + * output sample rate, applies any post-processing with @ref SampleFilter, + * and then delivers the stream of output samples through @ref + * OutputHandler. + */ + void ThreadEntry(); + }; + +} + +////////////////////////////////////////////// +// Template function implementations below. // +////////////////////////////////////////////// + + + +template +void mic_array::MicArray::ThreadEntry() +{ + int32_t sample_out[MIC_COUNT] = {0}; + + while(1){ + uint32_t* pdm_samples = PdmRx.GetPdmBlock(); + Decimator.ProcessBlock(sample_out, pdm_samples); + SampleFilter.Filter(sample_out); + OutputHandler.OutputSample(sample_out); + } +} \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/cpp/OutputHandler.hpp b/lib_mic_array/api/mic_array/cpp/OutputHandler.hpp new file mode 100644 index 00000000..be232fd3 --- /dev/null +++ b/lib_mic_array/api/mic_array/cpp/OutputHandler.hpp @@ -0,0 +1,306 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "mic_array/frame_transfer.h" + +#include + + +// This has caused problems previously, so just catch the problems here. +#if defined(MIC_COUNT) || defined(SAMPLE_COUNT) || defined(FRAME_COUNT) +# error Application must not define the following as precompiler macros: MIC_COUNT, SAMPLE_COUNT, FRAME_COUNT. +#endif + +using namespace std; + +namespace mic_array { + + /** + * @brief OutputHandler implementation which groups samples into + * non-overlapping multi-sample audio frames and sends entire frames to + * subsequent processing stages. + * + * This class template can be used as an OutputHandler with the @ref MicArray + * class template. See @ref MicArray::OutputHandler. + * + * Classes derived from this template collect samples into frames. A frame + * is a 2 dimensional array with one index corresponding to the audio channel + * and the other index corresponding to time step, e.g.: + * + * @code{.c} + * int32_t frame[MIC_COUNT][SAMPLE_COUNT]; + * @endcode + * + * Each call to @ref OutputSample() adds the sample to the current frame, and + * then iff the frame is full, uses its @ref FrameTx component to transfer the + * frame of audio to subsequent processing stages. Only one of every + * `SAMPLE_COUNT` calls to @ref OutputSample() results in an actual + * transmission to subsequent stages. + * + * With `FrameOutputHandler`, the thread receiving the audio will generally + * need to know how many microphone channels and how many samples to expect + * per frame (although, strictly speaking, that depends upon the chosen + * `FrameTransmitter` implementation). + * + * @tparam MIC_COUNT @parblock + * The number of audio channels in each sample and each frame. + * @endparblock + * + * @tparam SAMPLE_COUNT Number of samples per frame. @parblock + * The `SAMPLE_COUNT` template parameter is the number of samples assembled + * into each audio frame. Only completed frames are transmitted to subsequent + * processing stages. A `SAMPLE_COUNT` value of `1` effectively disables + * framing, transmitting one sample for each call made to @ref OutputSample. + * @endparblock + * + * @tparam FrameTransmitter @parblock + * The concrete type of the @ref FrameTx component of this class. + * \verbatim embed:rst + Like many classes in this library, `FrameOutputHandler` uses the :ref:`crtp`. + \endverbatim + * @endparblock + * + * @tparam FRAME_COUNT @parblock + * The number of frame buffers an instance of `FrameOutputHandler` should + * cycle through. Unless audio frames are communicated with subsequent + * processing stages through shared memory, the default value of `1` is usualy + * ideal. + * @endparblock + */ + template class FrameTransmitter, + unsigned FRAME_COUNT = 1> + class FrameOutputHandler + { + private: + + /** + * @brief Index of the frame currently being filled. + */ + unsigned current_frame = 0; + + /** + * @brief Index of the sample currently being filled. + */ + unsigned current_sample = 0; + + /** + * @brief Frame buffers for transmitted frames. + */ + int32_t frames[FRAME_COUNT][MIC_COUNT][SAMPLE_COUNT]; + + public: + + /** + * @brief `FrameTransmitter` used to transmit frames to the + * next stage for processing. + * + * `FrameTransmitter` is the CRTP type template parameter used in this + * class to control how frames of audio data are communicated with + * subsequent pipeline stages. + * + * The type supplied for `FrameTransmitter` must be a class template with + * two integer template parameters, corresponding to this class's + * `MIC_COUNT` and `SAMPLE_COUNT` template parameters respectively, + * indicating the shape of the frame object to be transmitted. + * + * The `FrameTransmitter` type is required to implement a single method: + * + * @code{.cpp} + * void OutputFrame(int32_t frame[MIC_COUNT][SAMPLE_COUNT]); + * @endcode + * + * `OutputFrame()` is called once for each completed audio frame and is + * responsible for the details of how the frame's data gets communicated + * to subsequent stages. For example, the @ref ChannelFrameTransmitter + * class template uses an XCore channel to send samples to another thread + * (by value). + * + * Alternative implementations might use shared memory or an RTOS queue to + * transmit the frame data, or might even use a port to signal the samples + * directly to an external DAC. + */ + FrameTransmitter FrameTx; + + public: + + /** + * @brief Construct new `FrameOutputHandler`. + * + * The default no-argument constructor for `FrameTransmitter` is used to + * create `FrameTx`. + */ + FrameOutputHandler() { } + + /** + * @brief Construct new `FrameOutputHandler`. + * + * Uses the provided FrameTransmitter to send frames. + * + * @param frame_tx Frame transmitter for sending frames. + */ + FrameOutputHandler(FrameTransmitter frame_tx) + : FrameTx(frame_tx) { } + + /** + * @brief Add new sample to current frame and output frame if filled. + * + * @param sample Sample to be added to current frame. + */ + void OutputSample(int32_t sample[MIC_COUNT]); + }; + + + /** + * @brief Frame transmitter which transmits frame over a channel. + * + * This class template is meant for use as the `FrameTransmitter` template + * parameter of @ref FrameOutputHandler. + * + * When using this frame transmitter, frames are transmitted over a channel + * using the frame transfer API in `mic_array/frame_transfer.h`. + * \verbatim embed:rst + Usually, a call to :c:func:`ma_frame_rx()` (with the other end of + `c_frame_out` as argument) should be used to receive the frame on + another thread. \endverbatim + * + * If the receiving thread is not waiting to receive the frame when @ref + * OutputFrame() is called, that method will block until the frame has been + * transmitted. In order to ensure there are no violations of the mic array's + * real-time constraints, the receiver should be ready to receive a frame as + * soon as it becomes available. + * + * @note While @ref OutputFrame() is blocking, it will not prevent the PDM rx + * interrupt from firing. + * + * Frames can be transmitted between tiles using this class. + * + * @tparam MIC_COUNT Number of audio channels in each frame. + * @tparam SAMPLE_COUNT Number of samples per frame. + */ + template + class ChannelFrameTransmitter + { + private: + + /** + * @brief Channel over which frames are transmitted. + * + * If the default constructor is used, @ref SetChannel() must be called to + * configure the channel over which frames are transmitted prior to any + * calls to @ref OutputFrame(). + */ + chanend_t c_frame_out; + + public: + + /** + * @brief Construct a `ChannelFrameTransmitter`. + * + * If this constructor is used, @ref SetChannel() must be called to + * configure the channel over which frames are transmitted prior to any + * calls to @ref OutputFrame(). + */ + ChannelFrameTransmitter() : c_frame_out(0) { } + + /** + * @brief Construct a `ChannelFrameTransmitter`. + * + * The supplied value of `c_frame_out` must be a valid chanend. + * + * @param c_frame_out Chanend over which frames will be transmitted. + */ + ChannelFrameTransmitter(chanend_t c_frame_out) : c_frame_out(c_frame_out) { } + + /** + * @brief Set channel used for frame transfers. + * + * The supplied value of `c_frame_out` must be a valid chanend. + * + * @param c_frame_out Chanend over which frames will be transmitted. + */ + void SetChannel(chanend_t c_frame_out); + + /** + * @brief Get the chanend used for frame transfers. + * + * @returns Channel to be used for frame transfers. + */ + chanend_t GetChannel(); + + /** + * @brief Transmit the specified frame. + * + * See @ref ChannelFrameTransmitter for additional details. + * + * @param frame Frame to be transmitted. + */ + void OutputFrame(int32_t frame[MIC_COUNT][SAMPLE_COUNT]); + }; + +} + + +////////////////////////////////////////////// +// Template function implementations below. // +////////////////////////////////////////////// + + + +template class FrameTransmitter, + unsigned FRAME_COUNT> +void mic_array::FrameOutputHandler::OutputSample( + int32_t sample[MIC_COUNT]) +{ + auto* cur_frame = reinterpret_cast( + &this->frames[this->current_frame][0][0]); + + for(int k = 0; k < MIC_COUNT; k++) + cur_frame[k][this->current_sample] = sample[k]; + + if(++current_sample == SAMPLE_COUNT){ + current_sample = 0; + current_frame++; + if(current_frame == FRAME_COUNT) current_frame = 0; + + FrameTx.OutputFrame( cur_frame ); + } +} + + + +template +void mic_array::ChannelFrameTransmitter::SetChannel( + chanend_t c_frame_out) +{ + this->c_frame_out = c_frame_out; +} + +template +chanend_t mic_array::ChannelFrameTransmitter::GetChannel() +{ + return this->c_frame_out; +} + + +template +void mic_array::ChannelFrameTransmitter::OutputFrame( + int32_t frame[MIC_COUNT][SAMPLE_COUNT]) +{ + ma_frame_tx(this->c_frame_out, + reinterpret_cast(frame), + MIC_COUNT, SAMPLE_COUNT); +} \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/cpp/PdmRx.hpp b/lib_mic_array/api/mic_array/cpp/PdmRx.hpp new file mode 100644 index 00000000..91508717 --- /dev/null +++ b/lib_mic_array/api/mic_array/cpp/PdmRx.hpp @@ -0,0 +1,658 @@ +// Copyright 2022-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include +#include +#include + +#include +#include +#include + +#include "mic_array.h" +#include "Util.hpp" + +// This has caused problems previously, so just catch the problems here. +#if defined(BLOCK_SIZE) || defined(CHANNELS_IN) || defined(CHANNELS_OUT) || defined(SUBBLOCKS) +# error Application must not define the following as precompiler macros: MIC_COUNT, CHANNELS_IN, CHANNELS_OUT, SUBBLOCKS. +#endif + +using namespace std; +extern "C" { + + /** + * @brief PDM rx interrupt configuration and context. + */ + typedef struct { + + /** + * Port on which PDM samples are received. + */ + port_t p_pdm_mics; + + /** + * Pointers to a pair of buffers used for storing captured PDM samples. + * + * The buffers themselves are allocated by an instance of @ref + * mic_array::PdmRxService. The idea is that while the PDM rx ISR is filling + * one buffer, the decimation thread is busy processing the contents of the + * other buffer. If the real-time constraint is maintained, the decimation + * thread will be finished with the contents of its buffer before the PDM rx + * ISR fills the other buffer. Once full, the PDM rx ISR does a double + * buffer pointer swap and hands the newly-filled buffer to the decimation + * thread. + */ + uint32_t* pdm_buffer[2]; + + /** + * Tracks the completeness of the buffer currently being filled. + * + * Each read of samples from `p_pdm_mics` gives one word of data. This + * variable tracks how many more port reads are required before the current + * buffer has been filled. + */ + unsigned phase; + + /** + * The number of words to read from `p_pdn_mics` to fill a buffer. + */ + unsigned phase_reset; + + /** + * Streaming chanend the PDM rx ISR uses to signal the decimation thread + * that another buffer is full and ready to be processed. + * + * The streaming channel itself is allocated by @ref + * mic_array::StandardPdmRxService, which owns the other end of the channel. + */ + chanend_t c_pdm_data; + + /** + * Used for detecting when the real-time constraint is violated by the + * decimation thread. + * + * Each time the decimation thread is given a block of PDM data to process, + * `credit` is reset to `2`. Each time the PDM rx ISR hands a block of PDM + * data to the decimation thread, this is decremented. + * + * @par Deadlock Condition + * @parblock + * @ref mic_array::StandardPdmRxService uses a streaming channel to + * facilitate communication between the two execution contexts used by the + * mic array, the decimation thread and the PDM rx ISR. A streaming channel + * is used because it allows the contexts to operate asynchronously. + * + * A channel has a 2 word buffer, and as long as there is room in the + * buffer, an `OUT` instruction putting a word (in this case, a pointer) + * into the channel is guaranteed not to block. This is important because + * the PDM rx ISR is typically configured on the same hardware thread as the + * decimation thread. + * + * If a thread is blocked on an `OUT` instruction to a channel, in order to + * unblock the thread, an `IN` must be issued on the other end of that + * channel. But because the PDM rx ISR is blocked, it cannot hand control + * back to the decimation thread, which means the decimation thread can + * never issue an `IN` instruction to unblock the ISR. The result is a + * deadlock. + * + * Unfortunately, there is no way for a thread to query a chanend to + * determine whether it will block if an `OUT` instruction is issued. That + * is why `credit` is used. Before issuing an `OUT` to `c_pdm_data`, the PDM + * rx ISR checks whether `credit` is non-zero. If so, the ISR issues the + * `OUT` instruction as normal and decrements `credit`. + * + * If `credit` is zero, the default behavior of PDM rx ISR is to raise an + * exception (`ET_ECALL`). This reflects the idea that it is generally + * better if system-breaking errors loudly announce themselves (at least by + * default). If using @ref mic_array::StandardPdmRxService, this behavior + * can be changed by passing `false` in a call to + * @ref mic_array::StandardPdmRxService::AssertOnDroppedBlock(), which will + * allow blocks of PDM data to be silently dropped (while still avoiding a + * permanent deadlock). + * @endparblock + */ + unsigned credit; + + /** + * Controls and records anti-deadlock behavior. + * + * If the PDM rx ISR finds that `credit` is `0` when it's time to send a + * filled buffer to the decimation thread, it uses `missed_blocks` to + * control whether the PDM rx ISR should raise an exception or silently drop + * the block of PDM data. + * + * If `missed_blocks` is `-1` (its default value) an exception is raised. + * Otherwise `missed_blocks` is used to record the number of blocks that + * have been quietly dropped. + */ + unsigned missed_blocks; + } pdm_rx_isr_context_t; + + /** + * Configuration and context of the PDM rx ISR when @ref + * mic_array::StandardPdmRxService is used in interrupt mode. + * + * `pdm_rx_isr` (`pdm_rx_isr.S`) directly allocates this object as + * configuration and state parameters required by that interrupt routine. + */ + extern pdm_rx_isr_context_t pdm_rx_isr_context; + + /** + * @brief Configure port to use `pdm_rx_isr` as an interrupt routine. + * + * This function configures `p_pdm_mics` to use `pdm_rx_isr` as its interrupt + * vector and enables the interrupt on the current hardware thread. + * + * This function does NOT unmask interrupts. + * + * @param p_pdm_mics Port resource to enable ISR on. + */ + static inline + void enable_pdm_rx_isr( + const port_t p_pdm_mics) + { + asm volatile( + "setc res[%0], %1 \n" + "ldap r11, pdm_rx_isr \n" + "setv res[%0], r11 \n" + "eeu res[%0] " + : + : "r"(p_pdm_mics), "r"(XS1_SETC_IE_MODE_INTERRUPT) + : "r11" ); + } + +} + + +namespace mic_array { + + + + /** + * @brief Collects PDM sample data from a port. + * + * Derivatives of this class template are intended to be used for the `TPdmRx` + * template parameter of @ref MicArray, where it represents the @ref + * MicArray::PdmRx component of the mic array. + * + * An object derived from `PdmRxService` collects blocks of PDM samples from a + * port and makes them available to the decimation thread as the blocks are + * completed. + * + * `PdmRxService` is a base class using CRTP. Subclasses extend `PdmRxService` + * providing themselves as the template parameter `SubType`. + * + * This base class provides the logic for aggregating PDM data taken from + * a port into blocks, and a subclass is required to provide methods + * `SubType::ReadPort()`, `SubType::SendBlock()` and `SubType::GetPdmBlock()`. + * + * `SubType::ReadPort()` is responsible for reading 1 word of data from + * `p_pdm_mics`. See @ref StandardPdmRxService::ReadPort() as an example. + * + * `SubType::SendBlock()` is provided a block of PDM data as a pointer and is + * responsible for signaling that to the subsequent processing stage. See + * @ref StandardPdmRxService::SendBlock() as an example. + * + * `ReadPort()` and `SendBlock()` are used by `PdmRxService` itself (when + * running as a thread, rather than ISR). + * + * `SubType::GetPdmBlock()` responsible for receiving a block of PDM data from + * `SubType::SendBlock()` as a pointer, deinterleaving the buffer contents, + * and returning a pointer to the PDM data in the format expected by the mic + * array unit's decimator component. See + * @ref StandardPdmRxService::GetPdmBlock() as an example. + * + * `GetPdmBlock()` is called by the decimation thread. The pair of functions, + * `SendBlock()` and `GetPdmBlock()` facilitate inter-thread communication, + * `SendBlock()` being called by the transmitting end of the communication + * channel, and `GetPdmBlock()` being called by the receiving end. + * + * @tparam BLOCK_SIZE Number of words of PDM data per block. + * @tparam SubType Subclass of `PdmRxService` actually being used. + */ + template + class PdmRxService + { + // @todo: Use a static assertion to check that SubType is in fact a sub-type + // of `PdmRxService`. + + public: + + /** + * @brief Number of words of PDM data per block. + * + * Typically (e.g. @ref TwoStageDecimator) `BLOCK_SIZE` will be exactly + * the number of words of PDM samples required to produce exactly one new + * output sample for the mic array unit's output stream. + * + * Once `BlockSize` words have been read into one of the @ref block_data, + * buffers, PDM rx will signal to the decimator thread that new PDM data + * is available for processing. + */ + static constexpr unsigned BlockSize = BLOCK_SIZE; + + protected: + /** + * @brief Port from which to collect PDM data. + */ + port_t p_pdm_mics; + + /** + * Number of words left to capture for the current block. + */ + unsigned phase = BLOCK_SIZE; + + /** + * @brief Buffers for PDM data blocks. + * + * The PDM rx service will swap back and forth between filling these two + * buffers. + */ + uint32_t block_data[2][BLOCK_SIZE]; + + /** + * @brief PDM block redirection pointers. + * + * Each time a new block of data is ready, a double buffer pointer swap + * is performed and `blocks[1]` is passed to `SubType::SendBlock()` so + * that it can be signaled to the next processing stage. + */ + uint32_t* blocks[2] = {&block_data[0][0], &block_data[1][0]}; + + public: + + /** + * @brief Set the port from which to collect PDM samples. + */ + void SetPort(port_t p_pdm_mics); + + /** + * @brief Perform a port read and if a new block has completed, signal. + */ + void ProcessNext(); + + /** + * @brief Entry point for PDM processing thread. + * + * This function loops forever, calling `ProcessNext()` with each + * iteration. + */ + void ThreadEntry(); + + }; + + + /** + * @brief PDM rx service which uses a streaming channel to send a block of + * data by pointer. + * + * This class can run the PDM rx service either as a stand-alone thread or + * through an interrupt. + * + * @par Inter-context Transfer + * @parblock + * A streaming channel is used to transfer control of the PDM data block + * between execution contexts (i.e. thread->thread or ISR->thread). + * + * The mic array unit receives blocks of PDM data from an instance of this + * class by calling @ref GetPdmBlock(), which blocks until a new PDM block is + * available. + * @endparblock + * + * @par Layouts + * @parblock + * The buffer transferred by `SendBlock()` contains `CHANNELS_IN*SUBBLOCKS` + * words of PDM data for `CHANNELS_IN` microphone channels. The words are + * stored in reverse order of arrival. \verbatim embed:rst + See :cpp:func:`mic_array::deinterleave_pdm_samples` for additional details + on this format.\endverbatim + * + * Within `GetPdmBlock()` (i.e. mic array thread) the PDM data block is + * deinterleaved and copied to another buffer in the format required by the + * decimator component, which is returned by `GetPdmBlock()`. This buffer + * contains samples for `CHANNELS_OUT` microphone channels. + * @endparblock + * + * @par Channel Filtering + * @parblock + * In some cases an application may be required to capture more microphone + * channels than should actually be processed by subsequent processing stages + * (including the decimator component). For example, this may be the case if 4 + * microphone channels are desired but only an 8 bit wide port is physically + * available to capture the samples. + * + * This class template has a parameter both for the number of channels to be + * captured by the port (`CHANNELS_IN`), as well as for the number of channels + * that are to be output for consumption by the `MicArray`'s decimator + * component (`CHANNELS_OUT`). + * + * When the PDM microphones are in an SDR configuration, `CHANNELS_IN` must be + * the width (in bits) of the XCore port to which the microphones are + * physically connected. When in a DDR configuration, `CHANNELS_IN` must be + * twice the width (in bits) of the XCore port to which the microphones are + * physically connected. + * + * `CHANNELS_OUT` is the number of microphone channels to be consumed by the + * mic array's decimator component (i.e. must be the same as the `MIC_COUNT` + * template parameter of the decimator component). If all port pins are + * connected to microphones, this parameter will generally be the same as + * `CHANNELS_IN`. + * @endparblock + * + * @par Channel Index (Re-)Mapping + * @parblock + * + * The input channel index of a microphone depends on the pin to which it is + * connected. Each pin connected to a port has a bit index for that port, + * given in the 'Signal Description and GPIO' section of your package's + * datasheet. + * + * Suppose an `N`-bit port is used to capture microphone data, and a + * microphone is connected to bit `B` of that port. In an SDR microphone + * configuration, the input channel index of that microphone is `B`, the + * same as the port bit index. + * + * In a DDR configuration, that microphone will be on either input channel + * index `B` or `B+N`, depending on whether that microphone is configured for + * in-phase capture or out-of-phase capture. + * + * Sometimes it may be desirable to re-order the microphone channel indices. + * This is likely the case, for example, when `CHANNELS_IN > CHANNELS_OUT`. + * + * By default output channels are mapped from the input channels with the same + * index. If `CHANNELS_IN > CHANNELS_OUT`, this means that the input channels + * with the highest `CHANNELS_IN-CHANNELS_OUT` indices are dropped by default. + * + * The `MapChannel()` and `MapChannels()` methods can be used to specify a + * non-default mapping from input channel indices to output channel indices. + * It takes a pointer to a `CHANNELS_OUT`-element array specifying the input + * channel index for each output channel. + * @endparblock + * + * @tparam CHANNELS_IN The number of microphone channels to be captured by + * the port. + * @tparam CHANNELS_OUT The number of microphone channels to be delivered by + * this `StandardPdmRxService` instance. + * @tparam SUBBLOCKS The number of 32-sample sub-blocks to be captured for + * each microphone channel. + */ + template + class StandardPdmRxService : public PdmRxService> + { + /** + * @brief Alias for parent class. + */ + using Super = PdmRxService>; + + private: + /** + * @brief Streaming channel over which PDM blocks are sent. + */ + streaming_channel_t c_pdm_blocks; + + /** + * @brief Maps input channel indices to output channel indices. + * + * The output channel with index `k` will be derived from the input channel with index `channel_map[k]`. + * + * By default, the mapping will be direct (i.e. `channel_map[k] = k`). + * + * Set with the `MapChannel()` or `MapChannels()` methods. + */ + unsigned channel_map[CHANNELS_OUT]; + + /** + * @brief Buffer for output PDM data. + * + * A pointer to this array is delivered to the Decimator component for + * decimation. `GetPdmBlock()` (called from the mic array thread) + * populates this array (based on `channel_map`) after deinterleaving the + * PDM input buffer. + */ + uint32_t out_block[CHANNELS_OUT][SUBBLOCKS]; + + public: + + /** + * @brief Read a word of PDM data from the port. + * + * @return A `uint32_t` containing 32 PDM samples. If `MIC_COUNT >= 2` the + * samples from each port will be interleaved together. + */ + uint32_t ReadPort(); + + /** + * @brief Send a block of PDM data to a listener. + * + * @param block PDM data to send. + */ + void SendBlock(uint32_t block[CHANNELS_IN * SUBBLOCKS]); + + /** + * @brief Initialize this object with a channel and port. + * + * @param p_pdm_mics Port to receive PDM data on. + */ + void Init(port_t p_pdm_mics); + + /** + * @brief Set the input-output mapping for all output channels. + * + * By default, input channel index `k` maps to output channel index `k`. + * + * This method overrides that behavior for all channels, re-mapping each + * output channel such that output channel `k` is derived from input + * channel `map[k]`. + * + * @note Changing the channel mapping while the mic array unit is running + * is not recommended. + * + * @param map Array containing new channel map. + */ + void MapChannels(unsigned map[CHANNELS_OUT]); + + /** + * @brief Set the input-output mapping for a single output channel. + * + * By default, input channel index `k` maps to output channel index `k`. + * + * This method overrides that behavior for a single output channel, + * configuring output channel `out_channel` to be derived from input + * channel `in_channel`. + * + * @note Changing the channel mapping while the mic array unit is running + * is not recommended. + * + * @param out_channel Output channel index to be re-mapped. + * @param in_channel New source channel index for `out_channel`. + */ + void MapChannel(unsigned out_channel, unsigned in_channel); + + /** + * @brief Install ISR for PDM reception on the current core. + * + * @note This does not unmask interrupts. + */ + void InstallISR(); + + /** + * @brief Unmask interrupts on the current core. + */ + void UnmaskISR(); + + /** + * @brief Get a block of PDM data. + * + * Because blocks of PDM samples are delivered by pointer, the caller must + * either copy the samples or finish processing them before the next block + * of samples is ready, or the data will be clobbered. + * + * @note This is a blocking call. + * + * @returns Pointer to block of PDM data. + */ + uint32_t* GetPdmBlock(); + + /** + * @brief Set whether dropped PDM samples should cause an assertion. + * + * If `doAssert` is set to `true` (default), the PDM rx ISR will raise an + * exception (`ET_CALL`) if it is ready to deliver a PDM block to the mic + * array thread when the mic array thread is not ready to receive it. If + * `false`, dropped blocks can be tracked through + * `pdm_rx_isr_context.missed_blocks`. + */ + void AssertOnDroppedBlock(bool doAssert); + }; + +} + +////////////////////////////////////////////// +// Template function implementations below. // +////////////////////////////////////////////// + + +////////////////////////////////////////////// +// PdmRxService // +////////////////////////////////////////////// + +template +void mic_array::PdmRxService::SetPort(port_t p_pdm_mics) +{ + this->p_pdm_mics = p_pdm_mics; +} + + +template +void mic_array::PdmRxService::ProcessNext() +{ + this->blocks[0][--phase] = static_cast(this)->ReadPort(); + + if(!phase){ + this->phase = BLOCK_SIZE; + uint32_t* ready_block = this->blocks[0]; + this->blocks[0] = this->blocks[1]; + this->blocks[1] = ready_block; + + static_cast(this)->SendBlock(ready_block); + } +} + + +template +void mic_array::PdmRxService::ThreadEntry() +{ + while(1){ + this->ProcessNext(); + } +} + + + +////////////////////////////////////////////// +// StandardPdmRxService // +////////////////////////////////////////////// + + +template +uint32_t mic_array::StandardPdmRxService + ::ReadPort() +{ + return port_in(this->p_pdm_mics); +} + + +template +void mic_array::StandardPdmRxService + ::SendBlock(uint32_t block[CHANNELS_IN*SUBBLOCKS]) +{ + s_chan_out_word(this->c_pdm_blocks.end_a, + reinterpret_cast( &block[0] )); +} + + +template +void mic_array::StandardPdmRxService + ::Init(port_t p_pdm_mics) +{ + for(int k = 0; k < CHANNELS_OUT; k++) + this->channel_map[k] = k; + + this->c_pdm_blocks = s_chan_alloc(); + + this->SetPort(p_pdm_mics); +} + + +template +void mic_array::StandardPdmRxService + ::MapChannels(unsigned map[CHANNELS_OUT]) +{ + for(int k = 0; k < CHANNELS_OUT; k++) + this->channel_map[k] = map[k]; +} + + +template +void mic_array::StandardPdmRxService + ::MapChannel(unsigned out_channel, unsigned in_channel) +{ + this->channel_map[out_channel] = in_channel; +} + + +template +void mic_array::StandardPdmRxService + ::InstallISR() +{ + pdm_rx_isr_context.p_pdm_mics = this->p_pdm_mics; + pdm_rx_isr_context.c_pdm_data = this->c_pdm_blocks.end_a; + pdm_rx_isr_context.pdm_buffer[0] = &this->block_data[0][0]; + pdm_rx_isr_context.pdm_buffer[1] = &this->block_data[1][0]; + pdm_rx_isr_context.phase_reset = CHANNELS_IN*SUBBLOCKS-1; + pdm_rx_isr_context.phase = CHANNELS_IN*SUBBLOCKS-1; + + enable_pdm_rx_isr(this->p_pdm_mics); +} + +template +void mic_array::StandardPdmRxService + ::AssertOnDroppedBlock(bool doAssert) +{ + pdm_rx_isr_context.missed_blocks = doAssert? -1 : 0; +} + +template +void mic_array::StandardPdmRxService + ::UnmaskISR() +{ + interrupt_unmask_all(); +} + +template +uint32_t* mic_array::StandardPdmRxService + ::GetPdmBlock() +{ + // Has to be in a critical section to avoid race conditions with ISR. + interrupt_mask_all(); + pdm_rx_isr_context.credit = 2; + interrupt_unmask_all(); + + + uint32_t* full_block = (uint32_t*) s_chan_in_word(this->c_pdm_blocks.end_b); + mic_array::deinterleave_pdm_samples(full_block, SUBBLOCKS); + + uint32_t (*block)[CHANNELS_IN] = (uint32_t (*)[CHANNELS_IN]) full_block; + + for(int ch = 0; ch < CHANNELS_OUT; ch++) { + for(int sb = 0; sb < SUBBLOCKS; sb++) { + unsigned d = this->channel_map[ch]; + this->out_block[ch][sb] = block[SUBBLOCKS-1-sb][d]; + } + } + return &this->out_block[0][0]; +} diff --git a/lib_mic_array/api/mic_array/cpp/Prefab.hpp b/lib_mic_array/api/mic_array/cpp/Prefab.hpp new file mode 100644 index 00000000..a692ccc2 --- /dev/null +++ b/lib_mic_array/api/mic_array/cpp/Prefab.hpp @@ -0,0 +1,520 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include + +#include "MicArray.hpp" +#include "mic_array/etc/filters_default.h" + +// This has caused problems previously, so just catch the problems here. +#if defined(MIC_COUNT) || defined(MICS_IN) || defined(FRAME_SIZE) || defined(USE_DCOE) +# error Application must not define the following as precompiler macros: MIC_COUNT, MICS_IN, FRAME_SIZE, USE_DCOE. +#endif + +namespace mic_array { + + /** + * @brief Namespace containing simplified versions of `MicArray`. + * + * This namespace contains simplified implementations of the `MicArray` class + * where its component types (e.g. `MicArray.Decimator` or `MicArray.PdmRx`) + * are already baked in, simplifying usage in an application. + * + * Most applications need not extend or modify the typical mic array behavior, + * and so using one of the templates defined here will usually be the right + * choice. + */ + namespace prefab { + + /** + * @brief Class template for a typical bare-metal mic array unit. + * + * This prefab is likely the right starting point for most applications. + * + * With this prefab, the decimator will consume one device core, and the + * PDM rx service can be run either as an interrupt, or as an additional + * thread. Normally running as an interrupt is recommended. + * + * For the first and second stage decimation filters, this prefab uses the + * coefficients provided with this library. The first stage uses a + * decimation factor of 32, and the second stage is configured to use a + * decimation factor of 6. + * + * To get 16 kHz audio output from the `BasicMicArray` prefab, then, the + * PDM clock must be configured to `3.072 MHz` + * (`3.072 MHz / (32 * 6) = 16 kHz`). + * + * @par Sub-Components + * @parblock + * Being derived from @ref mic_array::MicArray, an instance of + * `BasicMicArray` has 4 sub-components responsible for different portions + * of the work being done. These sub-components are `PdmRx`, `Decimator`, + * `SampleFilter` and `OutputHandler`. See the documentation for `MicArray` + * for more details about these. + * @endparblock + * + * @par Template Parameters Details + * @parblock + * The template parameter `MIC_COUNT` is the number of microphone channels + * to be processed and output. + * + * The template parameter `FRAME_SIZE` is the number of samples in each + * output frame produced by the mic array. Frame data is communicated using + * the API found in `mic_array/frame_transfer.h`. + * \verbatim embed:rst + Typically :c:func:`ma_frame_rx()` will be the right function to use in a + receiving thread to retrieve audio frames. ``ma_frame_rx()`` receives + audio frames with shape ``(MIC_COUNT,FRAME_SIZE)``, meaning that all + samples corresponding to a given channel will end up in a contiguous + block of memory. Instead of ``ma_frame_rx()``, + :c:func:`ma_frame_rx_transpose()` can be used to swap the dimensions, + resulting in the shape ``(FRAME_SIZE, MIC_COUNT)``.\endverbatim + * + * Note that calls to `ma_frame_rx()` or `ma_frame_rx_transpose()` will + * block until a frame becomes available on the specified chanend. + * + * If the receiving thread is not waiting to retrieve the audio frame from + * the mic array when it becomes available, the pipeline may back up and + * cause samples to be dropped. It is the responsibility of the application + * developer to ensure this does not happen. + * + * The boolean template parameter `USE_DCOE` indicates whether the DC offset + * elimination filter should be applied to the output of the second stage + * decimator. DC offset elimination is an IIR filter intended to ensure + * audio samples on each channel tend towards zero-mean. + * + * \verbatim embed:rst + For more information about DC offset elimination, see + :ref:`sample_filters` \endverbatim. + * + * If `USE_DCOE` is `false`, no further filtering of the second stage + * decimator's output will occur. + * + * The template parameter `MICS_IN` indicates the number of microphone + * channels to be captured by the `PdmRx` component of the mic array unit. + * This will often be the same as `MIC_COUNT`, but in some applications, + * `MIC_COUNT` microphones must be physically connected to an XCore port + * which is not `MIC_COUNT` (SDR) or `MIC_COUNT/2` (DDR) bits wide. + * + * In these cases, capturing the additional channels (likely not even + * physically connected to PDM microphones) is unavoidable, but further + * processing of the additional (junk) channels can be avoided by using + * `MIC_COUNT < MICS_IN`. The mapping which tells the mic array unit how to + * derive output channels from input channels can be configured during + * initialization by calling `StandardPdmRxService::MapChannels()` on the + * `PdmRx` sub-component of the `BasicMicarray`. + * + * If the application uses an SDR microphone configuration (i.e. 1 + * microphone per port pin), then `MICS_IN` must be the same as the port + * width. If the application is running in a DDR microphone configuration, + * `MICS_IN` must be twice the port width. `MICS_IN` defaults to + * `MIC_COUNT`. + * @endparblock + * + * @par Allocation + * @parblock + * Before a mic array unit can be started or initialized, it must be + * allocated. + * + * Instances of `BasicMicArray` are self-contained with respect to memory, + * needing no external buffers to be supplied by the application. Allocating + * an instance is most easily accomplished by simply declaring the mic array + * unit. An example follows. + * + * @code{.cpp} + * #include "mic_array/cpp/Prefab.hpp" + * ... + * using AppMicArray = mic_array::prefab::BasicMicArray; + * AppMicArray mics; + * @endcode + * + * Here, `mics` is an allocated mic array unit. The example (and all that + * follow) assumes the macros used for template parameters are defined + * elsewhere. + * @endparblock + * + * @par Initialization + * @parblock + * Before a mic array unit can be started, it must be initialized. + * + * `BasicMicArray` reads PDM samples from an XCore port, and delivers frames + * of audio data over an XCore channel. To this end, an instance of + * `BasicMicArray` needs to be given the resource IDs of the port to be read + * and the chanend to transmit frames over. This can be accomplished in + * either of two ways. + * + * If the resource IDs for the port and chanend are available as the mic + * array unit is being allocated, one option is to explicitly construct the + * `BasicMicArray` instance with the required resource IDs using the + * two-argument constructor: + * + * @code{.cpp} + * using AppMicArray = mic_array:prefab::BasicMicArray; + * AppMicArray mics(PORT_PDM_MICS, c_frames_out); + * @endcode + * + * Otherwise (typically), these can be set using + * `BasicMicArray::SetPort(port_t)` and + * `BasicMicArray::SetOutputChannel(chanend_t)` to set the port and channel + * respectively. + * + * @code{.cpp} + * AppMicArray mics; + * ... + * void app_init(port_t p_pdm_mics, chanend_t c_frames_out) + * { + * mics.SetPort(p_pdm_mics); + * mics.SetOutputChannel(p_pdm_mics); + * } + * @endcode + * + * Next, the ports and clock block(s) used by the PDM rx service need to be + * configured appropriately. This is not accomplished directly through the + * `BasicMicArray` object. Instead, a `pdm_rx_resources_t` struct + * representing these hardware resources is constructed and passed to + * `mic_array_resources_configure()`. See the documentation for + * `pdm_rx_resources_t` and `mic_array_resources_configure()` for more + * details. + * + * Finally, if running `BasicMicArray`'s PDM rx service within an ISR, + * before the mic array unit can be started, the ISR must be installed. This + * is accomplished with a call to `BasicMicArray::InstallPdmRxISR()`. + * Installing the ISR will _not_ unmask it. + * + * @note `BasicMicArray::InstallPdmRxISR()` installs the ISR on the + * hardware thread that calls the method. In most cases, installing it in + * the same thread as the decimator is the right choice. + * @endparblock + * + * @par Begin Processing (PDM rx ISR) + * @parblock + * After it has been initialized, starting the mic array unit with the PDM + * rx service running as an ISR, three steps are required. + * + * First, the PDM clock must be started. This is accomplished with a call to + * `mic_array_pdm_clock_start()`. The same `pdm_rx_resources_t` that was + * passed to `mic_array_resources_configure()` is given as an argument here. + * + * Second, the PDM rx ISR that was installed during initialization must be + * unmasked. This is accomplished by calling + * `BasicMicArray::UnmaskPdmRxISR()` on the mic array unit. + * + * Finally, the mic array processing thread must be started. The entry point + * for the mic array thread is `BasicMicArray::ThreadEntry()`. + * + * A typical pattern will include all three of these steps in a single + * function which wraps the mic array thread entry point. + * + * @code{.cpp} + * AppMicArray mics; + * pdm_rx_resources_t pdm_res; + * ... + * MA_C_API // alias for 'extern "C"' + * void app_mic_array_task() + * { + * mic_array_pdm_clock_start(&pdm_res); + * mics.UnmaskPdmRxISR(); + * mics.ThreadEntry(); + * } + * @endcode + * + * Using this pattern, `app_mic_array_task()` is a C-compatible function + * which can be called from a multi-tile `main()` in an XC file. Then, + * `app_mic_array_task()` is called directly from a `par {...}` block. For + * example, + * + * @code{.c} + * main(){ + * ... + * par { + * on tile[1]: { + * ... // Do initialization stuff + * + * par { + * app_mic_array_task(); + * ... + * other_thread_on_tile1(); // other threads + * } + * } + * } + * } + * @endcode + * @endparblock + * + * @par Begin Processing (PDM Rx Thread) + * @parblock + * The procedure for running the mic array unit with the PDM rx component + * running as a stand-alone thread is much the same with just a couple key + * differences. + * + * When running PDM rx as a thread, no call to + * `BasicMicArray::UnmaskPdmRxISR()` is necessary. Instead, the + * application spawns a second thread (the first being the mic array + * processing thread) using `BasicMicArray::PdmRxThreadEntry()` as the + * entry point. + * + * `mic_array_pdm_clock_start()` must still be called, but here the + * requirement is that it be called from the hardware thread on which the + * PDM rx component is running (which, of course, cannot be the mic array + * thread). + * + * A typical application with a multi-tile XC `main()` will provide two + * C-compatible functions - one for each thread: + * + * @code{.cpp} + * MA_C_API + * void app_pdm_rx_task() + * { + * mic_array_pdm_clock_start(&pdm_res); + * mics.PdmRxThreadEntry(); + * } + * + * MA_C_API + * void app_mic_array_task() + * { + * mics.ThreadEntry(); + * } + * @endcode + * + * Notice that `app_mic_array_task()` above is a thin wrapper for + * `mics.ThreadEntry()`. Unfortunately, because the type of `mics` is a C++ + * class, `mics.ThreadEntry()` cannot be called directly from an XC file + * (including the one containing `main()`). Further, because a C++ class + * template was used, this library cannot provide a generic C-compatible + * call wrapper for the methods on a `MicArray` object. This unfortunately + * means it is necessary in some cases to create a thin wrapper such as + * `app_mic_array_task()`. + * + * The threads are spawned from XC main using a `par {...}` block: + * + * @code{.c} + * main(){ + * ... + * par { + * on tile[1]: { + * ... // Do initialization stuff + * + * par { + * app_mic_array_task(); + * app_pdm_rx_task(); + * ... + * other_thread_on_tile1(); // other threads + * } + * } + * } + * } + * @endcode + * @endparblock + * + * @par Real-Time Constraint + * @parblock + * Once the PDM rx thread is launched or the PDM rx interrupt has been + * unmasked, PDM data will start being collected and reported to the + * decimator thread. The application then must start the decimator thread + * within one output sample time (i.e. sample time for the output of the + * second stage decimator) to avoid issues. + * + * Once the mic array processing thread is running, the real-time constraint + * is active for the thread consuming the mic array unit's output, and it + * must waiting to receive an audio frame within one frame time. + * @endparblock + * + * @par Examples + * @parblock + * This library comes with examples which demonstrate how a mic array unit + * is used in an actual application. If you are encountering difficulties + * getting `BasicMicArray` to work, studying the provided examples may help. + * @endparblock + * + * @tparam MIC_COUNT Number of microphone channels. + * @tparam FRAME_SIZE Number of samples in each output audio frame. + * @tparam USE_DCOE Whether DC offset elimination should be used. + */ + template + class BasicMicArray + : public MicArray, + StandardPdmRxService, + // std::conditional uses USE_DCOE to determine which + // sample filter is used. + typename std::conditional, + NopSampleFilter>::type, + FrameOutputHandler> + { + + public: + /** + * `TParent` is an alias for this class template from which this class + * template inherits. + */ + using TParent = MicArray, + StandardPdmRxService, + typename std::conditional, + NopSampleFilter>::type, + FrameOutputHandler>; + + + /** + * @brief No-argument constructor. + * + * + * This constructor allocates the mic array and nothing more. + * + * Call BasicMicArray::Init() to initialize the decimator. + * + * Subsequent calls to `BasicMicArray::SetPort()` and + * `BasicMicArray::SetOutputChannel()` will also be required before any + * processing begins. + */ + constexpr BasicMicArray() noexcept {} + + /** + * @brief Initialize the decimator. + */ + void Init(); + + /** + * @brief Initialzing constructor. + * + * If the communication resources required by `BasicMicArray` are known + * at construction time, this constructor can be used to avoid further + * initialization steps. + * + * This constructor does _not_ install the ISR for PDM rx, and so that + * must be done separately if PDM rx is to be run in interrupt mode. + * + * @param p_pdm_mics Port with PDM microphones + * @param c_frames_out (non-streaming) chanend used to transmit frames. + */ + BasicMicArray( + port_t p_pdm_mics, + chanend_t c_frames_out); + + /** + * @brief Set the PDM data port. + * + * This function calls `this->PdmRx.Init(p_pdm_mics)`. + * + * This should be called during initialization. + * + * @param p_pdm_mics The port to receive PDM data on. + */ + void SetPort( + port_t p_pdm_mics); + + /** + * @brief Set the audio frame output channel. + * + * This function calls + * `this->OutputHandler.FrameTx.SetChannel(c_frames_out)`. + * + * This must be set prior to entrying the decimator task. + * + * @param c_frames_out The channel to send audio frames on. + */ + void SetOutputChannel( + chanend_t c_frames_out); + + /** + * @brief Entry point for PDM rx thread. + * + * This function calls `this->PdmRx.ThreadEntry()`. + * + * @note This call does not return. + */ + void PdmRxThreadEntry(); + + /** + * @brief Install the PDM rx ISR on the calling thread. + * + * This function calls `this->PdmRx.InstallISR()`. + */ + void InstallPdmRxISR(); + + /** + * @brief Unmask interrupts on the calling thread. + * + * This function calls `this->PdmRx.UnmaskISR()`. + */ + void UnmaskPdmRxISR(); + + + }; + + } +} + +////////////////////////////////////////////// +// Template function implementations below. // +////////////////////////////////////////////// + + +template +void mic_array::prefab::BasicMicArray::Init() +{ + this->Decimator.Init((uint32_t*) stage1_coef, stage2_coef, stage2_shr); +} + + +template +mic_array::prefab::BasicMicArray + ::BasicMicArray( + port_t p_pdm_mics, + chanend_t c_frames_out) : TParent( + StandardPdmRxService(p_pdm_mics), + FrameOutputHandler( + ChannelFrameTransmitter( + c_frames_out))) +{ + this->Decimator.Init((uint32_t*) stage1_coef, stage2_coef, stage2_shr); +} + + +template +void mic_array::prefab::BasicMicArray + ::SetOutputChannel(chanend_t c_frames_out) +{ + this->OutputHandler.FrameTx.SetChannel(c_frames_out); +} + + +template +void mic_array::prefab::BasicMicArray + ::SetPort(port_t p_pdm_mics) +{ + this->PdmRx.Init(p_pdm_mics); +} + + +template +void mic_array::prefab::BasicMicArray + ::PdmRxThreadEntry() +{ + this->PdmRx.ThreadEntry(); +} + + +template +void mic_array::prefab::BasicMicArray + ::InstallPdmRxISR() +{ + this->PdmRx.InstallISR(); +} + + +template +void mic_array::prefab::BasicMicArray + ::UnmaskPdmRxISR() +{ + this->PdmRx.UnmaskISR(); +} diff --git a/lib_mic_array/api/mic_array/cpp/SampleFilter.hpp b/lib_mic_array/api/mic_array/cpp/SampleFilter.hpp new file mode 100644 index 00000000..d47b54f8 --- /dev/null +++ b/lib_mic_array/api/mic_array/cpp/SampleFilter.hpp @@ -0,0 +1,112 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include + +// This has caused problems previously, so just catch the problems here. +#if defined(MIC_COUNT) +# error Application must not define the following as precompiler macros: MIC_COUNT. +#endif + +using namespace std; + +namespace mic_array { + + /** + * @brief SampleFilter which does nothing. + * + * To be used as the `TSampleFilter` template parameter of @ref MicArray when + * no post-decimation filtering is desired. + * + * Calls to `NopSampleFilter::Filter()` are intended to be optimized out at + * compile time. + * + * @tparam MIC_COUNT Number of microphone channels. + */ + template + class NopSampleFilter + { + public: + /** + * @brief Do nothing. + */ + void Filter(int32_t sample[MIC_COUNT]) {}; + }; + + /** + * @brief Filter which applies DC Offset Elimination (DCOE). + * + * To be used as the `TSampleFilter` template parameter of @ref MicArray when + * DCOE is desired as post-processing after the decimation filter. + * + * The filter is a simple first-order IIR filter which applies the following + * filter equation: + * + * @code + * R = 255.0 / 256.0 + * y[t] = R * y[t-1] + x[t] - x[t-1] + * @endcode + * + * @tparam MIC_COUNT Number of microphone channels. + */ + template + class DcoeSampleFilter + { + + protected: + /** + * @brief State of DCOE filters. + */ + dcoe_chan_state_t state[MIC_COUNT]; + + public: + + /** + * @brief Initialize the filter states. + * + * The filter states must be initialized prior to calls to `Filter()`. + */ + void Init(); + + /** + * @brief Apply DCOE filter on samples. + * + * `sample` is an array of samples to be filtered, and is updated + * in-place. + * + * The filter states must have been initialized with a call to `Init()` + * prior to calling this function. + * + * @param sample Samples to be filtered. Updated in-place. + */ + void Filter(int32_t sample[MIC_COUNT]); + }; +} + +////////////////////////////////////////////// +// Template function implementations below. // +////////////////////////////////////////////// + + +template +void mic_array::DcoeSampleFilter::Init() +{ + dcoe_state_init(&state[0], MIC_COUNT); +} + + +template +void mic_array::DcoeSampleFilter::Filter( + int32_t sample[MIC_COUNT]) +{ + dcoe_filter(&sample[0], &state[0], &sample[0], MIC_COUNT); +} \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/cpp/Util.hpp b/lib_mic_array/api/mic_array/cpp/Util.hpp new file mode 100644 index 00000000..dcc22982 --- /dev/null +++ b/lib_mic_array/api/mic_array/cpp/Util.hpp @@ -0,0 +1,90 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include + +namespace mic_array { + + /** + * @brief Deinterleave the channels of a block of PDM data + * + * PDM samples received on a port are shifted into a 32-bit buffer in such a + * way that the samples for each microphone channel are all interleaved with + * one another. The first stage decimator, however, requires these to be + * separated. + * + * `samples` must point to a buffer containing `(MIC_COUNT*s2_dec_factor)` + * words of PDM data. Because the decimation factor for the first stage + * decimator is a fixed value of `32`, `32` PDM samples from each microphone + * is enough to produce one output sample (a `MIC_COUNT`-element vector) from + * the first stage decimator. `32*s2_dec_factor` PDM samples for each of the + * `MIC_COUNT` microphone channels is then exactly what is required to produce + * a single output sample from the second stage decimator. + * + * The PDM data will be deinterleaved in-place. + * + * @par Input Format + * + * On input, the format of the buffer to which `samples` points is assumed to + * be such that the following function will extract (only) the `k`th sample + * for microphone channel `n` (where `k` is a time index, not a memory index): + * + * @code{.c} + * unsigned get_sample(uint32_t* samples, + * unsigned MIC_COUNT, unsigned s2_dec_factor, + * unsigned n, unsigned k) + * { + * const end_word = MIC_COUNT * s2_dec_factor - 1; // chronologically first + * const unsigned samp_per_word = 32 / MIC_COUNT; + * const words_from_end = k / samp_per_word; + * const uint32_t word_val = samples[end_word-words_from_end]; + * const unsigned bit_offset = (k % end_word) + n; + * return (word_val >> bit_offset) & 1; + * } + * @endcode + * + * Here, the words of `samples` are stored in reverse order (older samples are + * at higher word indices), and within a word the oldest samples are the least + * significant bits. The LSb of a word is always microphone channel `0`, and + * the MSb of a word is always microphone channel `MIC_COUNT-1`. + * + * @par Output Format + * + * Upon return, the format of the buffer to which samples points will be such + * that the following function will extract (only) the `k`th sample for + * microphone channel `n`: + * + * @code{.c} + * unsigned get_sample(uint32_t* samples, + * unsigned MIC_COUNT, unsigned s2_dec_factor, + * unsigned n, unsigned k) + * { + * const unsigned subblock = (s2_dec_factor-1)-(k/32); + * const unsigned word_val = samples[subblock * MIC_COUNT + n]; + * return (word_val >> (k%32)) & 1; + * } + * @endcode + * + * Here, each word contains samples from only a single channel, with words at + * higher addresses containing older samples. `samples[0]` contains the newest + * samples for microphone channel `0`, and `samples[MIC_COUNT-1]` contains the + * newest samples for microphone channel `MIC_COUNT-1`. `samples[MIC_COUNT]` + * contains the next-oldest set of samples for channel `0`, and so on. + * + * + * + * @tparam MIC_COUNT Number of channels represented in PDM data. + * One of `{1,2,4,8}` + * + * @param samples Pointer to block of PDM samples. + * @param s2_dec_factor Stage2 decimator decimation factor. + */ + template + void deinterleave_pdm_samples( + uint32_t* samples, + unsigned s2_dec_factor); + + +} \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/dc_elimination.h b/lib_mic_array/api/mic_array/dc_elimination.h new file mode 100644 index 00000000..edfa935d --- /dev/null +++ b/lib_mic_array/api/mic_array/dc_elimination.h @@ -0,0 +1,115 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "api.h" +#include + +C_API_START + +/** + * @brief DC Offset Elimination (DCOE) State + * + * This is the required state information for a single channel to which the DC + * offset elimination filter is to be applied. + * + * To apply the DC offset elimination filter to multiple channels + * simultaneously, an array of `dcoe_chan_state_t` should be used. + * + * `dcoe_state_init()` is used once to initialize an array of state objects, and + * `dcoe_filter()` is used on each consecutive sample to apply the filter and + * get the resulting output sample. + * + * DC offset elimination is an IIR filter. The state must persist between time + * steps. + * + * @par Use in lib_mic_array + * @parblock + * Typical users of lib_mic_array will not need to directly use this type or any + * functions which take it as a parameter. + * + * The C++ class template `mic_array::DcoeSampleFilter`, if used in an + * application's mic array unit, will allocate, initialize and apply the DCOE + * filter automatically. + * @endparblock + * + * @par With MicArray Prefabs + * @parblock + * The MicArray prefab `mic_array::prefab::BasicMicArray` has a `bool` template + * parameter `USE_DCOE` which indicates whether the + * `mic_array::DcoeSampleFilter` should be used. If `true`, DCOE will be + * enabled. + * @endparblock + * + * @par With Vanilla API + * @parblock + * When using the 'vanilla' API, DCOE is enabled by default. To disable DCOE + * when using this API, add a preprocessor definition to the compiler flags, + * setting `MIC_ARRAY_CONFIG_USE_DC_ELIMINATION` to `0`. + * @endparblock + */ +MA_C_API +typedef struct { + /** Previous output sample value. */ + int64_t prev_y; +} dcoe_chan_state_t; + + +/** + * @brief Initialize DCOE states. + * + * The DC offset elimination state needs to be intialized before the filter can + * be applied. This function initializes it. + * + * For correct behavior, the state vector `state` must persist between audio + * samples and is supplied with each call to `dcoe_filter()`. + * + * @param[in] state Array of `dcoe_chan_state_t` to be initialized. + * @param[in] chan_count Number of elements in `state`. + */ +MA_C_API +void dcoe_state_init( + dcoe_chan_state_t state[], + const unsigned chan_count); + + +/** + * @brief Apply DCOE filter. + * + * Applies the DC offset elimination filter to get a new output sample and + * updates the filter state. + * + * For correct behavior, this function should be called once per sample (here + * "sample" refers to a vector-valued quantity containing one element for each + * audio channel) of that stream. + * + * The index of each array (`state`, `new_input` and `new_output`) corresponds + * to the audio channel. The update associated with each audio channel is + * independent of each other audio channel. + * + * The equation used for each channel is: + * + * @code + * y[t] = R * y[t-1] + x[t] - x[t-1] + * @endcode + * + * where `t` is the current sample time index, `y[]` is the output signal, `x[]` + * is the input signal, and `R` is `(255.0/256)`. + * + * To filter a sample in-place use the same array for both the `new_input` and + * `new_output` arguments. + * + * @param[out] new_output Array into which the output sample will be placed. + * @param[in] state DC offset elimination state vector. + * @param[in] new_input New input sample. + * @param[in] chan_count Number of channels to be processed. + */ +MA_C_API +void dcoe_filter( + int32_t new_output[], + dcoe_chan_state_t state[], + int32_t new_input[], + const unsigned chan_count); + +C_API_END \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/etc/filters_default.h b/lib_mic_array/api/mic_array/etc/filters_default.h new file mode 100644 index 00000000..3df473e0 --- /dev/null +++ b/lib_mic_array/api/mic_array/etc/filters_default.h @@ -0,0 +1,99 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "mic_array/api.h" +#include "xmath/xmath.h" + +#include + +C_API_START + +/** + * @brief Macro indicating Stage 1 Decimation Factor + * + * This is the ratio of input sample rate to output sample rate for the first + * filter stage. + * + * @note In version 5.0 of lib_mic_array, this value is fixed (even if you + * choose not to use the default filter coefficients). + */ +#define STAGE1_DEC_FACTOR 32 + +/** + * @brief Macro indicating Stage 1 Filter Tap Count + * + * This is the number of filter taps in the first stage filter. + * + * @note In version 5.0 of lib_mic_array, this value is fixed (even if you + * choose not to use the default filter coefficients). + */ +#define STAGE1_TAP_COUNT 256 + +/** + * @brief Macro indicating Stage 1 Filter Word Count + * + * This is a helper macro to indicate the number of 32-bit words required to + * store the filter coefficients. + * + * @note Even though the coefficients are 16-bit, the related lib_mic_array + * structs and functions expect them to be contained in an array of `uint32_t`, + * rather than an array of `int16_t`. There are two reasons for this. + * The first is that the VPU instructions require loaded data to start at a + * word-aligned (0 mod 4) address. `uint32_t` allocated on the heap or stack + * are guaranteed by the compiler to be at word-aligned addresses. + * The second reason is to mitigate possible confusion regarding the arrangement + * of the filter coefficients in memory. Not only are the 16-bit coefficients not + * stored in order (e.g. `b[0], b[1], b[2], ...`), the bits of individual 16-bit + * coefficients are not stored together in memory. This is, again, due to the + * behavior of the VPU hardware. + */ +#define STAGE1_WORDS (STAGE1_TAP_COUNT)/2 + +/** + * @brief Stage 1 PDM-to-PCM Decimation Filter Default Coefficients + * + * These are the default coefficients for the first stage filter. + */ +extern const uint32_t stage1_coef[STAGE1_WORDS]; + + + + + +/** + * @brief Stage 2 Decimation Factor for default filter. + * + * This is the ratio of input sample rate to output sample rate for the second + * filter stage. + * + * While the second stage filter can be configured with a different decimation + * factor, this is the one used for the filter supplied with this library. + */ +#define STAGE2_DEC_FACTOR 6 + +/** + * @brief Stage 2 Filter tap count for default filter. + * + * This is the number of filter taps associated with the second stage filter + * supplied with this library. + */ +#define STAGE2_TAP_COUNT 65 + +/** + * @brief Stage 2 Decimation Filter Default Coefficients + * + * These are the default coefficients for the second stage filter. + */ +extern const int32_t stage2_coef[STAGE2_TAP_COUNT]; + +/** + * @brief Stage 2 Decimation Filter Default Output Shift + * + * This is the non-negative, rounding, arithmetic right-shift applied + * to the 40-bit accumulator to produce an output sample. + */ +extern const right_shift_t stage2_shr; + +C_API_END diff --git a/lib_mic_array/api/mic_array/etc/fir_1x16_bit.h b/lib_mic_array/api/mic_array/etc/fir_1x16_bit.h new file mode 100644 index 00000000..b10e9b90 --- /dev/null +++ b/lib_mic_array/api/mic_array/etc/fir_1x16_bit.h @@ -0,0 +1,51 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include + +#include "mic_array/api.h" + +C_API_START + +/** Function that computes an FIR over a 1-bit signal with 16-bit coefficients. + * The one-bit signal is stored as a sequence of bits, each of them representing + * -1 or +1. The coefficients are notionally a vector of 16-bti values, but with + * a few provisos: + * + * * The number of coefficients must be a multiple of 256, and N_256 (the third + * parameter) represents how many multiples there are. N must be at least 1 + * + * * The coefficients shall be in the range [-32767 .. 32767] + * + * * Coefficients are stored in slices of bits. A slice of the coefficient vector + * comprises 256 coefficients, so there are N_256 slices. + * Each slice occupies 256 * 16 / 32 = 128 words: 16 bits for each of the 256 + * elements, and there are 23 bits per word. The coefficients are decomposed + * over the words, and each group of eight words (256 bits) store subsequent + * bits of the coefficients values as follows. The bits in + * - words 0..7 have magnitude +/-1 + * - words 8..15 have magnitude +/-2 + * - ... + * - words 112..119 have magnitude +/-16384, and finally + * - words 120..127 have magnitude +/-32767: note that this is not 32768. + * 0 means +1, +2, +16384, etc, 1 means -1, -2, -16384 etc. + * + * Signal and coeff_1 must be word-aligned (hence the data type) + * the function returns the inner product of the signal with the coefficients in + * approximately 20 + N_256 * 20 thread-cycles. A 100 MHz thread can + * + * * 32x decimate with a 256-point FIR an 80 MHz PDM signal. + * * 32x decimate with a 512-point FIR an 40 MHz PDM signal. + * * 64x decimate with a 512-point FIR an 80 MHz PDM signal. + * + * @param signal the 1-bit signal (32-bit aligned) + * @param coeff_1 16-bit coefficients split as above (32-bit aligned) + * + * @returns The inner product + */ +MA_C_API +int fir_1x16_bit(uint32_t signal[], const uint32_t coeff_1[]); + +C_API_END \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/etc/xcore_compat.h b/lib_mic_array/api/mic_array/etc/xcore_compat.h new file mode 100644 index 00000000..a76b0260 --- /dev/null +++ b/lib_mic_array/api/mic_array/etc/xcore_compat.h @@ -0,0 +1,42 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +/** + * The `` headers cannot be safely included from XC files, but + * several of the types defined in those headers need to be available in XC. + * This header is a work-around which defines those types for XC but includes + * them for C or CPP files. + */ + +#ifdef __XC__ + +extern "C" { + + typedef unsigned xclock_t; + typedef unsigned port_t; + typedef unsigned chanend_t; + + typedef struct { + unsigned end_a; + unsigned end_b; + } streaming_channel_t; + + typedef struct { + unsigned end_a; + unsigned end_b; + } channel_t; + +} + +#else //__XC__ + +#include +#include +#include +#include +#include + +#endif //__XC__ + diff --git a/lib_mic_array/api/mic_array/frame_transfer.h b/lib_mic_array/api/mic_array/frame_transfer.h new file mode 100644 index 00000000..be1d95ca --- /dev/null +++ b/lib_mic_array/api/mic_array/frame_transfer.h @@ -0,0 +1,130 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. +#pragma once + +#include "api.h" +#include "etc/xcore_compat.h" + +#include + +/** + * @defgroup frame_transfer_h_ frame_transfer.h + */ + +C_API_START + +/** + * @brief Transmit 32-bit PCM frame over a channel. + * + * This function transmits the 32-bit PCM frame `frame[]` over the channel + * `c_frame_out`. + * + * This is a blocking call which will wait for a receiver to accept the data + * from the channel. Typically this will be accomplished with a call to + * `ma_frame_rx()` or `ma_frame_rx_transpose()`. + * + * The receiver is not required to be on the same tile as the sender. + * + * @note Internally, a channel transaction is established to reduce the overhead + * of channel communication. Any custom functions are used to receive + * this frame in an application, they must wrap the channel reads in a + * (slave) channel transaction. See `xcore/channel_transaction.h`. + * + * @warning No protocol is used to ensure consistency between the frame layout + * of the transmitter and receiver. Disagreement about frame size will + * likely cause one side to block indefinitely. It is the + * responsibility of the application author to ensure consistency + * between transmitter and receiver. + * + * @param c_frame_out Channel over which to send frame. + * @param frame Frame to be transmitted. + * @param channel_count Number of channels represented in the frame. + * @param sample_count Number of samples represented in the frame. + */ +MA_C_API +void ma_frame_tx( + const chanend_t c_frame_out, + const int32_t frame[], + const unsigned channel_count, + const unsigned sample_count); + + +/** + * @brief Receive 32-bit PCM frame over a channel. + * + * This function receives a PCM frame over `c_frame_in`. Normally, the frame + * will have been transmitted using `ma_frame_tx()`. The received frame is + * stored in `frame[]`. + * + * This is a blocking call which does not return until the frame has been fully + * received. + * + * The sender is not required to be on the same tile as the receiver. + * + * @note Internally, a channel transaction is established to reduce the overhead + * of channel communication. This function may only be used to receive the + * frame if the transmitter has wrapped the channel writes in a (master) + * channel transaction. See `xcore/channel_transaction.h`. + * + * @warning No protocol is used to ensure consistency between the frame layout + * of the transmitter and receiver. Disagreement about frame size will + * likely cause one side to block indefinitely. It is the + * responsibility of the application author to ensure consistency + * between transmitter and receiver. + * + * @param frame Buffer to store received frame. + * @param c_frame_in Channel from which to receive frame. + * @param channel_count Number of channels represented in the frame. + * @param sample_count Number of samples represented in the frame. + */ +MA_C_API +void ma_frame_rx( + int32_t frame[], + const chanend_t c_frame_in, + const unsigned channel_count, + const unsigned sample_count); + + +/** + * @brief Receive 32-bit PCM frame over a channel with transposed dimensions. + * + * This function receives a PCM frame over `c_frame_in`. Normally, the frame + * will have been transmitted using `ma_frame_tx()`. The received frame is + * stored in `frame[]`. + * + * Unlike `ma_frame_rx()`, this function reorders the frame elements as they are + * received. `ma_frame_tx()` always transmits the frame elements in memory + * order. This function swaps the channel and sample axes so that if the + * transmitter frame has shape `(CHANNEL, SAMPLE)`, the caller's frame array + * will have shape `(SAMPLE, CHANNEL)`. + * + * This is a blocking call which does not return until the frame has been fully + * received. + * + * The sender is not required to be on the same tile as the receiver. + * + * @note Internally, a channel transaction is established to reduce the overhead + * of channel communication. This function may only be used to receive the + * frame if the transmitter has wrapped the channel writes in a (master) + * channel transaction. See `xcore/channel_transaction.h`. + * + * @warning No protocol is used to ensure consistency between the frame layout + * of the transmitter and receiver. Disagreement about frame size will + * likely cause one side to block indefinitely. It is the + * responsibility of the application author to ensure consistency + * between transmitter and receiver. + * + * @param frame Buffer to store received frame. + * @param c_frame_in Channel from which to receive frame. + * @param channel_count Number of channels represented in the frame. + * @param sample_count Number of samples represented in the frame. + */ +MA_C_API +void ma_frame_rx_transpose( + int32_t frame[], + const chanend_t c_frame_in, + const unsigned channel_count, + const unsigned sample_count); + + +C_API_END \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/impl/setup_impl.h b/lib_mic_array/api/mic_array/impl/setup_impl.h new file mode 100644 index 00000000..fc4c9679 --- /dev/null +++ b/lib_mic_array/api/mic_array/impl/setup_impl.h @@ -0,0 +1,17 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +// Doxygen gets confused when it sees this. +#ifndef __DOXYGEN__ + +static inline +unsigned mic_array_mclk_divider( + const unsigned master_clock_freq, + const unsigned pdm_clock_freq) +{ + return master_clock_freq / pdm_clock_freq; +} + +#endif \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/pdm_resources.h b/lib_mic_array/api/mic_array/pdm_resources.h new file mode 100644 index 00000000..22cd3f64 --- /dev/null +++ b/lib_mic_array/api/mic_array/pdm_resources.h @@ -0,0 +1,111 @@ +// Copyright 2021-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. +#pragma once + +#include "api.h" +#include "etc/xcore_compat.h" + +#include "xmath/xmath.h" + +#include + + +C_API_START + + +/** + * @brief Collection of resources IDs required for PDM capture. + * + * This struct is a container for the IDs of the XCore hardware resources used + * by the mic array unit's PdmRx component for capturing PDM data from a port. + * + * An object of this type will be used for initializing and starting the mic + * array unit. + */ +MA_C_API +typedef struct { + + /** + * @brief Resource ID of the 1-bit port on which the master audio clock signal + * is received. + * + * The master audio clock will be divided by a clock block to produce the PDM + * sample clock. + * + * This port will be configured as an input. + */ + port_t p_mclk; + + /** + * @brief Resource ID of the 1-bit port through which the PDM sample clock is + * signaled. + * + * The PDM sample clock is used by the PDM microphones to trigger sample + * conversion. + * + * This port will be configured as an output. + */ + port_t p_pdm_clk; + + /** + * @brief Resource ID of the port on which PDM samples are received. + * + * In an SDR configuration, the number of microphone channels is the width of + * this port. In a DDR configuration, the number of microphone channels is + * twice the width of this port. + * + * This port will be configured as an input. + */ + port_t p_pdm_mics; + + /** + * @brief Resource ID of the clock block used to derive the PDM clock from the + * master audio clock. + * + * In SDR configurations this is also the PDM data capture clock. + */ + clock_t clock_a; + + /** + * @brief Resource ID of the clock block used only in DDR configurations to + * trigger reads of the PDM data. + * + * If operating in an SDR configuration, `clock_b` is `0`. A value of `0` is + * what indicates an SDR configuration is being used. + */ + clock_t clock_b; +} pdm_rx_resources_t; + + +/** + * @brief Construct a @ref pdm_rx_resources_t for an SDR configuration. + * + * `pdm_rx_resources_t.clock_b` is initialized to `0`, indicating an SDR + * configuration. + * + * @param P_MCLK Master audio clock port resource ID. + * @param P_PDM_CLK PDM sample clock port resource ID. + * @param P_PDM_MICS PDM microphone data port resource ID. + * @param CLOCK_A PDM clock and capture clock block resource ID. + */ +#define PDM_RX_RESOURCES_SDR(P_MCLK, P_PDM_CLK, P_PDM_MICS, CLOCK_A) \ + { (port_t) (P_MCLK), (port_t) (P_PDM_CLK), (port_t) (P_PDM_MICS), \ + (clock_t) (CLOCK_A) } + + +/** + * @brief Construct a @ref pdm_rx_resources_t for a DDR configuration. + * + * @param P_MCLK Master audio clock port resource ID. + * @param P_PDM_CLK PDM sample clock port resource ID. + * @param P_PDM_MICS PDM microphone data port resource ID. + * @param CLOCK_A PDM clock clock block resource ID. + * @param CLOCK_B PDM capture clock block resource ID. + */ +#define PDM_RX_RESOURCES_DDR(P_MCLK, P_PDM_CLK, P_PDM_MICS, CLOCK_A, CLOCK_B) \ + { (port_t) (P_MCLK), (port_t) (P_PDM_CLK), (port_t) (P_PDM_MICS), \ + (clock_t) (CLOCK_A), (clock_t) (CLOCK_B) } + + + +C_API_END diff --git a/lib_mic_array/api/mic_array/setup.h b/lib_mic_array/api/mic_array/setup.h new file mode 100644 index 00000000..4a44d3a1 --- /dev/null +++ b/lib_mic_array/api/mic_array/setup.h @@ -0,0 +1,125 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. +#pragma once + +#include "mic_array.h" + +C_API_START + +/** + * @brief Configure the hardware resources needed by the mic array. + * + * Several hardware resources are needed to correctly run the mic array, + * including 3 ports and 1 or 2 clock blocks (depending on whether SDR or DDR + * mode is used). This function configures these resources for operation with + * the mic array. + * + * The `pdm_rx_resources_t` struct is a container for identifying precisely + * these resources. All three ports are reset by this function; any existing + * port configuration will be clobbered. + * + * The parameter `divide` is the ratio of the audio master clock to the desired + * PDM clock rate. For example, to generate a desired 3.072 MHz PDM clock from + * an audio master clock with frequency 24.576 MHz, a `divide` value of 8 is + * needed. \verbatim embed:rst + Divide can also be calculated from the master and PDM clock frequencies using + :c:func:`mic_array_mclk_divider()`.\endverbatim + * + * `pdm_res->p_mclk` is the resource ID for the 1-bit port on which the audio + * master clock is received. This function will enable this port and configure + * it as the source port for `pdm_res->clock_a` and for `pdm_res->clock_b` if + * operating in a DDR configuration. + * + * `pdm_res->clock_a` is the resource ID for the first (in SDR configuration, + * the only) clock block required by the mic array. Clock A divides the audio + * master clock (by a factor of `divide`) to generate the PDM clock. This + * function enables it with the audio master clock as its source. + * + * `pdm_res->p_pdm_clk` is the resource ID for the 1-bit port from which the PDM + * clock will be signaled to the microphones. This function enables it and + * configures Clock A as its source clock. + * + * `pdm_res->clock_b` is the resource ID for a second clock block, which is only + * required by the mic array in a DDR configuration. In DDR mode, this function + * enables Clock B with the audio master clock as its source. The divider for + * Clock B is half of that for Clock A (so it runs at twice the frequency). In + * a DDR configuration Clock B is used as the PDM capture clock. In an SDR + * configuration, this field must be set to 0 (this is how SDR/DDR is + * determined). + * + * `pdm_res->p_pdm_mics` is the resource ID for the port on which PDM data is + * received. This function enables it and configures it as a 32-bit buffered + * input. If operating in an SDR configuration, Clock A is used as the capture + * clock. If operating in a DDR configuration, Clock B is used as its capture + * clock. + * + * This function only configures and does not start either Clock A or Clock B. + * A call to `mic_array_pdm_clock_start()` with `pdm_res` as the argument can be + * used to start the clock(s). + * + * This function should be called during initialization, before any PDM data can + * be captured or processed. + * + * @param pdm_res The hardware resources used by the mic array. + * @param divide The divider to generate the PDM clock from the master clock. + */ +MA_C_API +void mic_array_resources_configure( + pdm_rx_resources_t* pdm_res, + int divide); + +/** + * @brief Start the PDM and capture clock(s). + * + * This function starts Clock A, and if using a DDR configuration, Clock B. + * + * `mic_array_resources_configure()` must have been called already to configure + * the resources indicated in `pdm_res`. + * + * Clock A is the PDM clock. Starting Clock A will cause `pdm_res->p_pdm_clk` to + * begin strobing the PDM clock to the PDM microphones. + * + * In an SDR configuration, Clock A is also the capture clock. In a DDR + * configuration, Clock B is the capture clock. In either case, the capture + * clock is also started, causing `pdm_res->p_pdm_mics` to begin storing PDM + * samples received on each period of the capture clock. + * + * In DDR configuration, this function starts Clock B, waits for a rising edge, + * and then starts Clock A, ensuring that the rising edges of the two clocks are + * not in phase. + * + * This function must be called prior to launching the decimator or PDM rx + * threads. + * + * @warning Once this function has been called, the port receiving PDM data will + * begin capturing samples. If the mic array unit is not started by the time the + * port buffer fills (`(32/mic_count)` sample times) samples will begin to be + * dropped. + * + * @param pdm_res The hardware resources used by the mic array. + */ +MA_C_API +void mic_array_pdm_clock_start( + pdm_rx_resources_t* pdm_res); + +/** + * @brief Compute clock divider for PDM clock. + * + * This is a convenience function which computes the required clock divider to + * derive a `pdm_clock_freq` Hz clock from a `master_clock_freq` Hz clock. This + * function is simple integer division. + * + * @param master_clock_freq The master audio clock frequency in Hz. + * @param pdm_clock_freq The desired PDM clock frequency in Hz. + * + * @returns Required clock divider. + */ +static inline +unsigned mic_array_mclk_divider( + const unsigned master_clock_freq, + const unsigned pdm_clock_freq); + + +#include "mic_array/impl/setup_impl.h" + +C_API_END \ No newline at end of file diff --git a/lib_mic_array/api/mic_array/util.h b/lib_mic_array/api/mic_array/util.h new file mode 100644 index 00000000..8dac6b0f --- /dev/null +++ b/lib_mic_array/api/mic_array/util.h @@ -0,0 +1,47 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include + +#include "api.h" +C_API_START + +/** + * @brief Perform deinterleaving for a 2-microphone subblock. + * + * Assembly function. + * + * Deinterleave the samples for 1 subblock of 2 microphones. Argument points to + * a 2 word buffer. + */ +MA_C_API +void deinterleave2(uint32_t*); + + +/** + * @brief Perform deinterleaving for a 4-microphone subblock. + * + * Assembly function. + * + * Deinterleave the samples for 1 subblock of 4 microphones. Argument points to + * a 4 word buffer. + */ +MA_C_API +void deinterleave4(uint32_t*); + + +/** + * @brief Perform deinterleaving for a 8-microphone subblock. + * + * Assembly function. + * + * Deinterleave the samples for 1 subblock of 8 microphones. Argument points to + * a 8 word buffer. + */ +MA_C_API +void deinterleave8(uint32_t*); + + +C_API_END \ No newline at end of file diff --git a/lib_mic_array/api/mic_array_frame.h b/lib_mic_array/api/mic_array_frame.h deleted file mode 100644 index 6df27ecb..00000000 --- a/lib_mic_array/api/mic_array_frame.h +++ /dev/null @@ -1,101 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_FRAME_H_ -#define MIC_ARRAY_FRAME_H_ - -#include -#include "mic_array_conf.h" -#include "dsp_fft.h" - -#ifndef MIC_DUAL_ENABLED - #define MIC_DUAL_ENABLED (0) -#endif - -// MIC_DUAL_FRAME_SIZE has no meaning if MIC_DUAL_ENABLED is false. -// Only define MIC_DUAL_FRAME_SIZE to a default value if MIC_DUAL_ENABLED is true. -#ifndef MIC_DUAL_FRAME_SIZE - #if defined(MIC_DUAL_ENABLED) && (MIC_DUAL_ENABLED != 0) - #define MIC_DUAL_FRAME_SIZE (1) - #endif -#endif - -#ifndef MIC_ARRAY_FRAME_SIZE - #define MIC_ARRAY_FRAME_SIZE (1) -#endif - -#ifndef MIC_ARRAY_WORD_LENGTH_SHORT - #define MIC_ARRAY_WORD_LENGTH_SHORT 0 -#endif - -#ifndef MIC_ARRAY_NUM_MICS - #warning Count of microphones not defined in mic_array_conf.h, defaulting to 16 - #define MIC_ARRAY_NUM_MICS 16 -#endif - -#if (MIC_ARRAY_NUM_MICS%4) != 0 - #warning Count of microphones(channels) must be set to a multiple of 4 - #if (MIC_ARRAY_NUM_MICS/4) == 0 - #undef MIC_ARRAY_NUM_MICS - #define MIC_ARRAY_NUM_MICS 4 - #warning MIC_ARRAY_NUM_MICS is now set to 4 - #elif (MIC_ARRAY_NUM_MICS/4) == 1 - #undef MIC_ARRAY_NUM_MICS - #define MIC_ARRAY_NUM_MICS 8 - #warning MIC_ARRAY_NUM_MICS is now set to 8 - #elif (MIC_ARRAY_NUM_MICS/4) == 2 - #undef MIC_ARRAY_NUM_MICS - #define MIC_ARRAY_NUM_MICS 12 - #warning MIC_ARRAY_NUM_MICS is now set to 12 - #elif (MIC_ARRAY_NUM_MICS/4) == 3 - #undef MIC_ARRAY_NUM_MICS - #define MIC_ARRAY_NUM_MICS 16 - #warning MIC_ARRAY_NUM_MICS is now set to 16 - #else - #error Too many microphones defined - #endif -#endif - -//Frames of frequency domain audio always have even number of channels, this rounds up. -#define MIC_ARRAY_NUM_FREQ_CHANNELS ((MIC_ARRAY_NUM_MICS + 1)/2) - -//This must have an even number of words -typedef struct { - unsigned sig_bits[4]; /** - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - image/svg+xml - - - - - - - - - - - - Div 8Decimator - - 16 ch3.072 MHz - - Div 4Decimator - - 4x4 ch 384 kHz - - - - 4x4 ch96 kHz - - SelectDC offsetFIR compGain comp - - 4x4 ch8..48 kHz - - OverlappingframesWIndowingBit reverse - - - - Div 4Decimator - - - - - - - - - - Voiceapp - Div NDecimatorN=2,4,6,8or 12 - Div NDecimatorN=2,4,6,8or 12 - SelectDC offsetFIR compGain comp - OverlappingframesWIndowingBit reverse - 4x4 ch8..48 kHz - 4x4 ch8..48 kHz - mic_array_pdm_rx() - mic_array_decimate_to_pcm_4ch() - k - - Div 4Decimator - - - - SelectDC offsetFIR compGain comp - - - OverlappingframesWIndowingBit reverse - - - Div NDecimatorN=2,4,6,8or 12 - - - Div 4Decimator - - - - SelectDC offsetFIR compGain comp - - - OverlappingframesWIndowingBit reverse - - - Div NDecimatorN=2,4,6,8or 12 - - - Div 8Decimator - - - - - diff --git a/lib_mic_array/doc/rst/chan4.pdf b/lib_mic_array/doc/rst/chan4.pdf deleted file mode 100644 index dca43ec0..00000000 Binary files a/lib_mic_array/doc/rst/chan4.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/chan4.svg b/lib_mic_array/doc/rst/chan4.svg deleted file mode 100644 index 3020b359..00000000 --- a/lib_mic_array/doc/rst/chan4.svg +++ /dev/null @@ -1,480 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - image/svg+xml - - - - - - - - - - - Div 8Decimator - - 4 ch3.072 MHz - - Div 4Decimator - - 1x4 ch 384 kHz - - - - 1x4 ch96 kHz - - SelectDC offsetFIR compGain comp - - 1x4 ch8..48 kHz - - OverlappingframesWIndowingBit reverse - - - - Voiceapp - Div NDecimatorN=2,4,6,8or 12 - 1x4 ch8..48 kHz - 1x4 ch8..48 kHz - mic_array_decimate_to_pcm_4ch() - mic_array_pdm_rx() - - diff --git a/lib_mic_array/doc/rst/chan4hires.pdf b/lib_mic_array/doc/rst/chan4hires.pdf deleted file mode 100644 index e914a4e6..00000000 Binary files a/lib_mic_array/doc/rst/chan4hires.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/chan4hires.svg b/lib_mic_array/doc/rst/chan4hires.svg deleted file mode 100644 index c3f00331..00000000 --- a/lib_mic_array/doc/rst/chan4hires.svg +++ /dev/null @@ -1,558 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - image/svg+xml - - - - - - - - - - - Div 8Decimator - - 4 ch3.072 MHz - - Div 4Decimator - - 1x4 ch 384 kHz - - - - 1x4 ch96 kHz - - SelectDC offsetFIR compGain comp - - 1x4 ch8..48 kHz - - OverlappingframesWIndowingBit reverse - - - - Voiceapp - Div NDecimatorN=2,4,6,8or 12 - 1x4 ch8..48 kHz - 1x4 ch8..48 kHz - - mic_array_pdm_rx() - mic_array_decimate_to_pcm_4ch() - - - HighResolutionDelay - - mic_array_hires_delay() - 1x4 ch 384 kHz - - diff --git a/lib_mic_array/doc/rst/chan8.pdf b/lib_mic_array/doc/rst/chan8.pdf deleted file mode 100644 index 830a5940..00000000 Binary files a/lib_mic_array/doc/rst/chan8.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/chan8.svg b/lib_mic_array/doc/rst/chan8.svg deleted file mode 100644 index 2fc3606c..00000000 --- a/lib_mic_array/doc/rst/chan8.svg +++ /dev/null @@ -1,644 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - image/svg+xml - - - - - - - - - - - - Div 8Decimator - - 8 ch3.072 MHz - - Div 4Decimator - - 2x4 ch 384 kHz - - - - 2x4 ch96 kHz - - SelectDC offsetFIR compGain comp - - 2x4 ch8..48 kHz - - OverlappingframesWIndowingBit reverse - - - - Div 4Decimator - - - - - - - - - - Voiceapp - Div NDecimatorN=2,4,6,8or 12 - Div NDecimatorN=2,4,6,8or 12 - SelectDC offsetFIR compGain comp - OverlappingframesWIndowingBit reverse - 2x4 ch8..48 kHz - 2x4 ch8..48 kHz - mic_array_pdm_rx() - mic_array_decimate_to_pcm_4ch() - k - diff --git a/lib_mic_array/doc/rst/chan8hires.pdf b/lib_mic_array/doc/rst/chan8hires.pdf deleted file mode 100644 index d6264939..00000000 Binary files a/lib_mic_array/doc/rst/chan8hires.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/chan8hires.svg b/lib_mic_array/doc/rst/chan8hires.svg deleted file mode 100644 index bde729f4..00000000 --- a/lib_mic_array/doc/rst/chan8hires.svg +++ /dev/null @@ -1,726 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - image/svg+xml - - - - - - - - - - - - Div 8Decimator - - 8 ch3.072 MHz - - Div 4Decimator - - 2x4 ch 384 kHz - - - - 2x4 ch96 kHz - - SelectDC offsetFIR compGain comp - - 2x4 ch8..48 kHz - - OverlappingframesWIndowingBit reverse - - - - Div 4Decimator - - - - - - - - - - Voiceapp - Div NDecimatorN=2,4,6,8or 12 - Div NDecimatorN=2,4,6,8or 12 - SelectDC offsetFIR compGain comp - OverlappingframesWIndowingBit reverse - 2x4 ch8..48 kHz - 2x4 ch8..48 kHz - - mic_array_pdm_rx() - mic_array_decimate_to_pcm_4ch() - - - HighResolutionDelay - - mic_array_hires_delay() - 2x4 ch 384 kHz - - diff --git a/lib_mic_array/doc/rst/first_stage.pdf b/lib_mic_array/doc/rst/first_stage.pdf deleted file mode 100644 index e6cad232..00000000 Binary files a/lib_mic_array/doc/rst/first_stage.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/first_stage_diagram.pdf b/lib_mic_array/doc/rst/first_stage_diagram.pdf deleted file mode 100644 index 36a53003..00000000 Binary files a/lib_mic_array/doc/rst/first_stage_diagram.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/first_stage_diagram.svg b/lib_mic_array/doc/rst/first_stage_diagram.svg deleted file mode 100644 index 0604944f..00000000 --- a/lib_mic_array/doc/rst/first_stage_diagram.svg +++ /dev/null @@ -1,792 +0,0 @@ - - - -image/svg+xml0.0 -0.1 -0.2 -0.3 -0.4 -Normalised Input Freq (i.e. 3.072MHz or 2.8224MHz) -−140 -−120 -−100 -−80 -−60 -−40 -−20 -0 -20 -Magnitude Response -0.5 -Passband -Stopband -Stopband -Stopband -Stopband -Stopband -Stopband -Stopband -StopbandBandwidth -PassbandBandwidth -StopbandAttenuation - \ No newline at end of file diff --git a/lib_mic_array/doc/rst/index.rst b/lib_mic_array/doc/rst/index.rst deleted file mode 100755 index 22e177a5..00000000 --- a/lib_mic_array/doc/rst/index.rst +++ /dev/null @@ -1,1132 +0,0 @@ -.. include:: ../../../README.rst - -Overview --------- - -This guide is designed so that the user can understand how to use ``lib_mic_array`` -by reading up to :ref:`section_examples`. :ref:`section_dc` and on are designed to explain -implementation details of ``lib_mic_array``, but do not need to be understood to use -it effectively. - -Up to sixteen PDM microphones can be attached to each high channel count PDM -interface (``mic_array_pdm_rx()``). One to four processing tasks, ``mic_array_decimate_to_pcm_4ch()``, -each process up to four channels. For 1-4 channels the library requires two logical cores: - - .. figure:: chan4.pdf - :width: 100% - - One to four channel count PDM interface - -or for 5-8 channels three logical cores as shown below: - - .. figure:: chan8.pdf - :width: 100% - - Five to eight count PDM interface - -|newpage| - -9-12 channels requires 5 logical cores and for 13-16 channels three six cores as shown below: - - .. figure:: chan16.pdf - :width: 100% - - Thirteen to sixteen count PDM interface - -The left most task, ``mic_array_pdm_rx()``, samples up to 8 microphones and filters the data to provide up to -eight 384 kHz data streams, split in two streams of four channels. The processing thread -decimates the signal to a user chosen sample rate (one of 48, 24, 16, 12, -or 8 kHz). If more than 8 channels are required then another ``mic_array_pdm_rx`` task can be created. -After the decimation to the output sample rate the following steps takes place: - -* Any DC offset is eliminated on the each channel. - -* The gain is corrected so that a maximum signal on the PDM microphone - corresponds to a maximum signal on the PCM signal. - -* The individual gain of each microphone can be compensated. - This can be used to compensate any differences in gains between the microphones in a system. - -* Frames of data are generated (with a frame size of 1 to 8192 in powers of two). - Frames can be set to overlap by half a frame. - -* An optional windowing function is applied to each frame. - -* The data can be stored in an index bit-reversed manner, so that it can be passed - into an FFT without having to do any preprocessing. - - -There is also an optional high resolution delay, running at up to 384kHz, that can be used to add to the -signal path channel specific delays. This can be used for high resolution delay and sum -beamforming. The task diagrams for 4 and 8 channel microphone arrays are given in -:ref:`figfourchanhires` and :ref:`figeightchanhires` respectively. - -.. _figfourchanhires: -.. figure:: chan4hires.pdf - :width: 100% - - One to four channel count PDM interface with hires delay lines - - -.. _figeightchanhires: -.. figure:: chan8hires.pdf - :width: 100% - - Five to eight count PDM interface with hires delay lines - -Higher channel counts are simple extensions of the above task diagrams. The high resolution delay task -requires a single extra core for up to 16 channels. All tasks requires a 62.5 MIPS core to run correctly, -therefore, all eight cores can be used simultaneously without timing problems developing -within ``lib_mic_array``. - -Version upgrade advisory ------------------------- - -2.+ -> 3.+ -............ - -When upgrading from version 2 to 3 the main interface change is from the function ``mic_array_decimate_to_pcm_4ch()``. -In version 2:: - - void mic_array_decimate_to_pcm_4ch( - streaming chanend c_from_pdm_interface); - -And in version 3:: - - void mic_array_decimate_to_pcm_4ch( - streaming chanend c_from_pdm_interface, - streaming chanend c_frame_output, mic_array_internal_audio_channels * channels); - -This new parameter is used for feeding internal audio channels into the decimators so that the internal channels -can benefit from the post decimation processing that the microphones receive (metadata collection, windowing, etc). -In order to upgrade a version 2 mic array to version 3 simply use the define ``MIC_ARRAY_NO_INTERNAL_CHANS`` for -the new parameter in the above function. - - -Typical memory usage --------------------- - -The memory usage of ``lib_mic_array`` is mostly dependent on the desired output rates and -the maximum number of channels. As lower output rates require greater decimation from the -input PDM their memory requirements are proportionally greater also. Below is a table of the -approximate memory usage against the channel count and decimation factor for each -final stage divider. - - =================== =============== ========================== - Decimation factor Channel count Approx memory usage (kB) - =================== =============== ========================== - 2 4 12.1 - 2 8 14.1 - 2 12 16.1 - 2 16 18.1 - 4 4 13.1 - 4 8 16.1 - 4 12 19.1 - 4 16 21.1 - 6 4 14.1 - 6 8 18.1 - 6 12 22.1 - 6 16 26.1 - 8 4 15.1 - 8 8 20.1 - 8 12 25.1 - 8 16 30.1 - 12 4 17.1 - 12 8 24.1 - 12 12 31.1 - 12 16 38.1 - =================== =============== ========================== - -These values should be use as a guide as actual memory usage may vary slightly. - - -Hardware characteristics ------------------------- - -The PDM microphones need a *clock input* and provide the PDM signal on a -*data output*. All PDM microphones share the same clock signal (buffered on -the PCB as appropriate), and output onto eight data wires that are -connected to a single 8-bit port: - -.. _pdm_wire_table: - -.. list-table:: PDM microphone data and signal wires - :class: vertical-borders horizontal-borders - - * - *CLOCK* - - Clock line, the PDM clock the used by the microphones to - drive the data out. - * - *DQ_PDM* - - The data from the PDM microphones on an 8 bit port. - -The only port passed into the library is the 8-bit data port. The library -assumes that the input port is clocked using the PDM clock and -requires no knowledge of PDM clock source. If a clock block ``pdmclk`` -is clocked at a 3.072 MHz rate, and the 8-bit port is p_pdm_mics then -the following statements will ensure that the PDM data -port is clocked by the PDM clock:: - - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - -The input clock for the microphones can be generated in a multitude of -ways. For example, a 3.072MHz clock can be generated on the board, or the xCORE can -divide down 12.288 MHz master clock. Or, if clock -accuracy is not important, the internal 100 MHz reference can be divided down to provide an -approximate clock. - -If an external master clock is input to the xCORE on a 1-bit port -``p_mclk`` that is running at 4x the desired PDM clock, then the PDM clock -can be generated by using the divider in a clock block:: - - configure_clock_src_divide(pdmclk, p_mclk, 4); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - -An approximate clock can be generated from the 500 MHz xCORE clock as follows:: - - configure_clock_xcore(pdmclk, 82); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - -It should be noted that this is a 3.049 MHz clock, which is 0.75% off a true -3.072 MHz clock. Finally, an approximate clock can also be generated from the 100 MHz reference -clock as follows:: - - configure_clock_ref(pdmclk, 17); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - -This gives a 2.941 MHz clock, which is 4.25% off a true 3.072 MHz clock. This may be acceptable -to simple Voice User Interfaces (VUIs). - -PDM microphones -............... - -PDM microphones typically have an initialization delay in the order of about 28ms. They also -typically have a DC offset. Both of these will be specified in the datasheet. - -Usage ------ - -All PDM microphone functions are accessed via the ``mic_array.h`` header:: - - #include - -You also have to add ``lib_mic_array`` to the -``USED_MODULES`` field of your application Makefile. - -A project must also include an extra header ``mic_array_conf.h`` which is used -to describe the mandatory configuration described later in this document. - -The PDM microphone interface and 4-channel decimators are instantiated as -parallel tasks that run in a ``par`` statement. For example, in an eight channel setup the two 4-channel decimators must -connect to the PDM interface via streaming channels:: - - #include - - clock pdmclk; - in buffered port:32 p_pdm_mics = XS1_PORT_8B; - in port p_mclk = XS1_PORT_1E; - out port p_pdm_clk = XS1_PORT_1F; - - int main() { - streaming chan c_pdm_to_dec[2]; - streaming chan c_ds_output[2]; - - configure_clock_src_divide(pdmclk, p_mclk, 4); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - par { - mic_array_pdm_rx(p_pdm_mics, c_pdm_to_dec[0], c_pdm_to_dec[1]); - - mic_array_decimate_to_pcm_4ch(c_pdm_to_dec[0], c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_pdm_to_dec[1], c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - - application(c_ds_output); - } - return 0; - } - -There is a further requirement that any application of a ``mic_array_decimate_to_pcm_4ch()`` -task must be on the same tile as the ``mic_array_decimate_to_pcm_4ch()`` task due to the shared -frame memory. - -As the PDM interface ``mic_array_pdm_rx()`` communicates over channels then the placement of it -is not restricted to the same tile as the decimators. - -Additionally, the high resolution delay task can be inserted between the PDM -interface and the decimators in the following fashion:: - - #include - - clock pdmclk; - in buffered port:32 p_pdm_mics = XS1_PORT_8B; - in port p_mclk = XS1_PORT_1E; - out port p_pdm_clk = XS1_PORT_1F; - - int main() { - streaming chan c_pdm_to_hires[2]; - streaming chan c_hires_to_dec[2]; - streaming chan c_ds_output[2]; - chan c_cmd; - - configure_clock_src_divide(pdmclk, p_mclk, 4); - configure_port_clock_output(p_pdm_clk, pdmclk); - configure_in_port(p_pdm_mics, pdmclk); - start_clock(pdmclk); - - par { - mic_array_pdm_rx(p_pdm_mics, c_pdm_to_hires[0], c_pdm_to_hires[1]); - - mic_array_hires_delay(c_pdm_to_hires, c_hires_to_dec, 2, c_cmd); - - mic_array_decimate_to_pcm_4ch(c_hires_to_dec[0], c_ds_output[0], MIC_ARRAY_NO_INTERNAL_CHANS); - mic_array_decimate_to_pcm_4ch(c_hires_to_dec[1], c_ds_output[1], MIC_ARRAY_NO_INTERNAL_CHANS); - - application(c_ds_output, c_cmd); - } - return 0; - } - - -Note, using the high resolution delay consumes an extra logical core. - - -High resolution delay task --------------------------- -The high resolution delay task, ``mic_array_hires_delay()``, is capable of implementing delays -with a resolution down to 2.3 microseconds (384kHz). It implements up to 16 delays lines of length -``MIC_ARRAY_HIRES_MAX_DELAY``, which has a default of 256. The delay line length can be overridden -by redefining it in ``mic_array_conf.h``. Each delay line sample is clocked at the PDM clock -rate divided by 8, that is, 384kHz for a 3.072MHz PDM clock and 352.8kHz for an PDM clock -of 2.8224MHz. - -By setting a positive delay of ``N`` samples on a channel then an input sample will take N extra -clocks to propagate to the decimators. Setting of the taps is done through the function -``mic_array_hires_delay_set_taps()`` which will do an atomic update of all the active delay lines tap -positions. The default delay on each channel is zero. -When the high resolution delay task is in use the define ``MIC_ARRAY_HIRES_MAX_DELAY`` should be -minimised for the application specific requirements as longer delay lines require more memory. - -See :ref:`section_api` for the API. - - -Accessing the samples ---------------------- -Samples are accessed in the form of frames. A frame is returned from the decimators in either the time -domain format, ``mic_array_frame_time_domain``, or in the FFT ready format, -``mic_array_frame_fft_preprocessed``. - -Time domain frames contain a single two-dimensional array, ``data``,with the first dimension being the -channel ID and the second dimension being the sample number. Samples are ordered ``0`` as the oldest -sample and increasing number being newer. - -FFT ready frames also contain a single two-dimensional array, ``data``. The data is preprocessed by the decimators -in such a way that the frames that are ready for direct processing by an DIT FFT. - - .. _figmemory: - .. figure:: memory_layout.pdf - :width: 70% - - Memory layout of simple audio and complex frames. - -Frames in the ``mic_array_frame_fft_preprocessed`` are not intended to be directly accessed by a user. Instead -when the frame has been processed by the FFT and cast to a ``mic_array_frame_frequency_domain`` then the -data can be manipulated. - - -Frames ------- - -The four channel decimators (``mic_array_pdm_rx()``) output frames of either *time domain audio* or -*FFT ready audio* prepared for an FFT. The define ``MIC_ARRAY_MAX_FRAME_SIZE_LOG2`` -(found in ``mic_array_conf.h``) should be used to allocate the arrays to -store the frames. This means that all frames structures will allocate -enough memory to allow for a frame size of two to the power of -``MIC_ARRAY_MAX_FRAME_SIZE_LOG2`` regardless of the size used in the -``decimator_config_common``. It is recommended that the ``len`` -field of ``decimator_config_common`` is always set to ``MIC_ARRAY_MAX_FRAME_SIZE_LOG2``. -Equally, the define ``MIC_ARRAY_NUM_MICS`` is used for allocating the memory -for the frame structure. This must be set to a multiple of 4. - -All frame types contain a two-dimensional ``data`` array. - -For simplicity of reading ``M`` will represent two to the power of ``MIC_ARRAY_MAX_FRAME_SIZE_LOG2`` and -``F`` will represent two to the power of ``len``. - -Time domain frames -.................. - -If *time domain audio* output is used (``index_bit_reversal`` is set to 0), then -data is stored into arrays in real time ordering. The arrays are of length ``M`` where -the first ``F`` (see :ref:`section_api`) entries contain valid data. All -entries between ``F`` and ``M`` are undefined. The first index of the ``data`` -element of the structure ``mic_array_frame_time_domain`` is used to address the -channel and the second index is used for the sample number with zero being the -oldest sample. - -Frames are initialised by the application with a call to ``mic_array_init_time_domain_frame()``. Pass it: - -* ``c_from_decimators``: An array of channels to the decimators. - -* ``decimator_count``: A count of the number of decimators (the number of - elements in the above array). - -* ``buffer``: used internally to maintain ownership of the shared memory between - the application and the decimators. - -* ``audio``: the array of audio frames, one (or two) of which will be owned by the - decimators at all times. - -* ``dc``: the configuration array to the decimators. - -Calls to ``mic_array_get_next_time_domain_frame()`` should be made to retrieve -subsequent audio frames. These calls require the exact same parameters as -``mic_array_init_time_domain_frame()``. - -FFT ready audio -............... - -If *FFT ready audio* output is used (``index_bit_reversal`` is set to 1), -then the data is stored in frames that are designed to be processed with an -FFT. The data is stored in arrays of length ``M`` where the first two ``F`` -entries contain valid data, each element storing a real and an imaginary -part. The data is stored in a bit reversed order (ie, the oldest element is -at index 0b0000....0000, the next oldest is at element 0b1000...0000, the -next one at element 0b0100...0000, etc up to element 0b1111...1111), and -the real elements store the even channels, whereas the imaginary elements -store the odd channels. A postprocess function must be applied after the -Decimate-in-Time (DIT) FFT in order to recover the frequency bins. - -Frames are initialised by the application by a call to -``mic_array_init_frequency_domain_frame()``. Pass it: - -* ``c_from_decimator``: An array of channels to the decimators - -* ``decimator_count``: A count of the number of decimators (the number of - elements in the above array). - -* ``buffer``: used internally to maintain ownership of the shared memory between - the application and the decimators. - -* ``f_complex``: the array of complex frames, one (or two) of which will be owned by the - decimators at all times. - -* ``dcc``: the configuration to the decimators. - -Calls to ``mic_array_get_next_frequency_domain_frame()`` should be made to retrieve -subsequent audio frames. These calls require the exact same parameters as -``mic_array_init_frequency_domain_frame()``. - - -Metadata -........ - -The metadata associated with frames is dependent on the final stage decimator ratio. For all -final stage decimators all frames will have metadata attached to them that records the frame number. -The frame counter is a unsigned 32 bit counter. Care must be taken when using this counter -for extended periods as it will wrap (at 48kHz the counter will wrap after ~24hrs). The -frame counter will increment every time a frame is accepted. - -When the final stage decimator is greater than 2 (corresponding to output sample rate of 24kHz -or 22.05kHz) then extra metadata will be collected. The metadata reported is: - -* ``sig_bits``: A mask of the significant bits used within the frame to represent the all the samples. - It is literally, initially ``sig_bits[n] = 0`` then ``sig_bits[n] | abs(s)`` for all ``s`` samples - within channel ``n`` of a frame. This is a 4 element array with each element representing a channel. - The significant bits mask is updated before windowing is applied. This means that if windowing is applied - then the true number of significant bits may be fewer than the reported number. - -* ``x``: an unused variable to pad the structure for double word alignment. - - -Using the decimators --------------------- - -The decimators reduce the high rate PCM down to lower rate PCM. They also prepare the audio -for subsequent algorithms, i.e. framing, windowing, etc. - -Setting up the decimators -......................... - -All decimators attach to an application via streaming channels and are configured -simultaneously with the ``mic_array_decimator_configure()`` function. The parameters to the -``mic_array_decimator_configure()`` function are described in a :ref:`section_api`. To start the -frame exchange process ``mic_array_init_frequency_domain_frame()`` or -``mic_array_init_time_domain_frame()`` must be called. Now the decimators are running -and will be outputting frames at the rate given by their configuration. - - .. _figstatemachine: - .. figure:: state_machine.pdf - :width: 100% - - Order of the function calls allowed to the decimators. - -The configuration of the decimators can be changed at any time so long as the -function calls respect the control flow given in :ref:`figstatemachine`. -Mixing of time and frequency domain functions is not supported without first calling -``mic_array_decimator_configure()``. - -Changing decimator configuration -................................ - -Once the decimators are running the configuration of the decimators remains constant. If a change of configuration -is required then a call to ``mic_array_decimator_configure()`` allows a complete reconfigure. This will -reconfigure and reset all attached decimators. The only configuration that will survive reconfiguration -is the DC offset memory. It is assumed that the microphone specific DC offset -remains fairly constant between reconfigurations. - - -``mic_array_conf.h`` --------------------- - -An application that uses ``lib_mic_array`` must define the header file -``mic_array_conf.h``. This header must define: - - * MIC_ARRAY_MAX_FRAME_SIZE_LOG2 - - This defines the maximum frame size (log 2) that the application could request to use. - The application may request frame sizes from 0 to ``MIC_ARRAY_MAX_FRAME_SIZE_LOG2``. - This should be kept small as it governs the memory required for - a frame. - - * MIC_ARRAY_NUM_MICS - - This defines the number of microphones in use. It is used for allocating memory in the - frame structures. - -Optionally, ``mic_array_conf.h`` may define: - - * MIC_ARRAY_DC_OFFSET_LOG2 - - The DC offset is removed with a high pass filter. ``DC_OFFSET_DIVIDER_LOG2`` - can be used to control the responsiveness of the filter vs the cut off frequency. - The default is 8, but setting this will override it. The value must not exceed 31. - See :ref:`section_dc` DC offset removal for further explanation. - - * MIC_ARRAY_MIC_ARRAY_HIRES_MAX_DELAY - - This defines the length of the high resolution delay lines. This should be set to a power - of two for efficiency. The default is 256. Increasing values will result in increasing memory - usage. - - * MIC_ARRAY_WORD_LENGTH_SHORT - - If this define is set to non-zero then this configures the output word length to be a 16 bit - short otherwise its left as 32 bit word length output. All internal processing will be done at - 32 bits, only during the write to frame memory will the truncation happen. - - * Microphone to channel remapping - - By default pin ``n`` is mapped to channel ``n`` for all the pins of the microphone input - port. If a reordering of pins to channels is required then the ordering can be overridden - with the define ``MIC_ARRAY_CHn`` and the pin``PINm`` where ``n`` and ``m`` are the channel - number and pin number respectively. For example, ``#define MIC_ARRAY_CH0 PIN2`` would map - pin 2 of the microphone input port to channel 0. Any undefined channel are left as the default - mapping. - - * MIC_ARRAY_FIXED_GAIN - - If this define will apply a fixed gain to the 64 bit output of the final stage decimation FIR. - The define should be set to an integer between -32 and +32. The define refers to the - amount that the signal should be left shifted by with positive number increasing the - signal and negative numbers decreasing the signal. The use of this can cause distortion. - There is no saturation logic included in the gain control. - -Optionally, ``mic_array_conf.h`` or ``xassert_conf.h`` may define: - - * DEBUG_MIC_ARRAY - - If this define will enable the debugging features of the mic array. These include timing assertions - and configuration validation. To enable set to non-zero. - -Four Channel Decimator ----------------------- - -The four channel decimator tasks are highly configurable tasks for outputting frames of -various sizes and formats. They can be used to produce frames suitable for time domain applications -or pre-process the frames ready for an FFT for frequency domain applications. The four -channel decimators, ``mic_array_decimate_to_pcm_4ch()``, have a number of configuration options -controlled by the structure ``decimator_config`` through the function ``mic_array_decimator_configure()``. -The decimators are controlled by two structures: ``decimator_config_common`` and ``decimator_config``, -where the former configuration is common to all microphones and the later is specific to the batch of 4 -microphones it interfaces to. The application has the option to control the -following settings through ``decimator_config_common``: - -* ``len``: The length of a frame: an arbitrary value < 2^15. The maximum allowed at run-time is given by two to the -power of ``MIC_ARRAY_MAX_FRAME_SIZE_LOG2``. At run-time the length can be dynamically configured by -setting the ``len`` member of ``mic_array_decimator_config_common``. If ``len`` -is less than 16, the frame size will be ``2^len``. If ``len`` is 16 or greater, the -frame size will be ``len``. - -* ``apply_dc_offset_removal``: This controls if the DC offset removal should be enabled - or not. Set to non-zero to enable, or ``0`` to not apply DC offset removal. - -* ``output_decimation_factor``: This specifies the decimation factor to apply to the PDM input - after an 8x decimator and 4x decimator has already been applied, i.e. for a 3.072MHz PDM clock the - ``output_decimation_factor`` will apply to a 96kHz sample rate. The valid values - are 2, 4, 6, 8 and 12. Common sample rates can be achieved by using - these decimation factors as follows: - - ======================== ========== ============== - output_decimation_factor PDM clock Sample rate - ======================== ========== ============== - 2 3.072 MHz 48 kHz - 4 3.072 MHz 24 kHz - 6 3.072 MHz 16 kHz - 8 3.072 MHz 12 kHz - 12 3.072 MHz 8 kHz - 2 2.8224 MHz 44.1 kHz - 4 2.8224 MHz 22.05 kHz - ======================== ========== ============== - - For other decimation factors see :ref:`section_advanced`. - -* ``coefs``: This is a pointer to an array of arrays containing the - coefficients for the final stage of decimation. For the provided - decimators set this to ``g_third_stage_div_X_fir`` where ``X`` is - the ``output_decimation_factor``. - If you wish to supply your own FIR coefficients see :ref:`section_advanced`. - -* ``fir_gain_compensation``: single value to compensate the gain of all the - previous decimators. This must be set to a value that depends on the - ``output_decimation_factor`` as follows: - - ======================== ======================= - output_decimation_factor fir_gain_compensation - ======================== ======================= - 2 FIR_COMPENSATOR_DIV_2 - 4 FIR_COMPENSATOR_DIV_4 - 6 FIR_COMPENSATOR_DIV_6 - 8 FIR_COMPENSATOR_DIV_8 - 12 FIR_COMPENSATOR_DIV_12 - ======================== ======================= - - If you wish to supply your own, this is a fixed point number in 5.27 format. To apply - a unity gain set to ``0``. - -* ``apply_mic_gain_compensation``: Set this to ``1`` if microphone gain compensation is - required. The compensation applied is controlled through the - ``mic_gain_compensation`` array in ``decimator_config`` below. - -* A windowing function can be passed in through ``windowing_function``. It is a pointer - to an array of integers that defines the windowing operator. Each sample - in the frame is multiplied by its associated window value and shifted - right by 31 places. This is performed before any index bit reversal (see - the next entry). The window function data is in 1.31 fixed point format and only the first half - of the window function is required. - -* If the data is going to be post processed using an FFT, then - ``index_bit_reversal`` can be set to 1. This will store the data elements - reordered according to a reversed bit pattern, suitable for an FFT - without "index bit reversing". As a side effect, it stores the data as - complex numbers, in such a way that a single complex FFT operates on two - microphones in parallel. - -* ``buffering_type``: ``DECIMATOR_HALF_FRAME_OVERLAP`` is used to specify half frame overlapping or sequential - frames is selected with ``DECIMATOR_NO_FRAME_OVERLAP``. - -* ``number_of_frame_buffers``: is used to specify the number of frames used by the - application plus decimators. This number should be at least two when ``DECIMATOR_NO_FRAME_OVERLAP`` - is in effect or three when ``DECIMATOR_HALF_FRAME_OVERLAP`` is in effect. This is due to the double - buffered nature of the decimators, i.e. the decimators are writing to (one or two) frames whilst - the application is using at least one. - -``decimator_config`` configures the per-channel information: - -* ``dcc``: This is a pointer to the common decimator configuration. - -* ``data``: This is the memory used to save the FIR samples. It must be an - array of size (4 channels x ``THIRD_STAGE_COEFS_PER_STAGE`` x ``sizeof(int)`` x - ``output_decimation_factor`` bytes). - -* ``mic_gain_compensation``: This is an array with four elements specifying - the relative compensation to apply to each microphone. Unity gain is - given by the value ``INT_MAX``. To equalise the gain of all microphones, - the quietest microphone should be given unity gain, and the gain of all - other microphones should be set proportionally lower. - -* ``channel_count``: this is the number of channels that is enabled. Set - this to 4 to enable all channels. If set to a value less than 4, only the - first ``channel_count`` channels are enabled. - -* ``async_interface_enabled``: This enables the non-blocking decimator interface - which requires ``frame size == 0`` and the use of ``mic_array_recv_samples``. - -The decimator configuration is applied by calling -the function ``mic_array_decimator_configure()`` with an array of chanends referring to -the decimators, a count of the number of decimators, and an array of -decimator configurations. - -The output of the decimator is 32-bit or 16-bit(MIC_ARRAY_WORD_LENGTH_SHORT != 0) PCM audio -at the requested sample rate. - -Intended usage model --------------------- - -The library has been designed with the intention of being able to dynamically -change its configuration, however, for minimal memory -footprint choosing a single output rate means the fewest FIR coefficient -end up in the binary. -A typical code structure will contain the following:: - - unsigned buffer; - mic_array_init_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - - while(1){ - mic_array_frame_time_domain * latest_frame = mic_array_get_next_time_domain_frame(c_ds_output, 2, buffer, audio, dc); - - } - -When a reconfigure is performed then there will be a short interval (to flush the FIR data buffers) -before the audio continues. - -Overlapping frames are supported so that frequency domain algorithms can be converted back into the -time domain without artefacts. See ``lib_dsp`` for FFT functions. - -The ``number_of_frame_buffers`` member of ``decimator_config_common`` is required so that a frame -buffer (array) can be used in a round-robin fashion. This means that the when the application calls -either ``mic_array_init_time_domain_frame()`` or ``mic_array_init_frequency_domain_frame()`` then -the ownership of one or two of the fames (depending on the overlapping scheme) -will be passed to the decimators. When a decimator has finished writing the oldest frame it is -returned to the application and the next in line is sent to the decimators. This means that by declaring -larger frame buffers and increasing ``number_of_frame_buffers`` then the application can have visibility -of longer periods of time at the expense of memory. - -Due to the round-robin nature of the library the application must be finished with the data in the -oldest frame before the decimators need it again. This is the nature of real time audio processing. - -Note: timing verification can be checked by switching on ``DEBUG_MIC_ARRAY``. This will enable an assertion -if the application of the decimators does not meet the real time requirements of the audio stream. - - -FIR memory ----------- - -For each decimator a block of memory must be allocated for storing FIR data. The size of the data -block must be:: - - Number of channels * THIRD_STAGE_COEFS_PER_STAGE * Decimation factor * sizeof(int) - -bytes. The data must also be double word aligned. For example, if the decimation factor was set to -``DECIMATION_FACTOR`` and two decimators were in use, then the memory allocation for the FIR memory -would look like:: - - int data[CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*DECIMATION_FACTOR]; - -The FIR memory must also be initialized in order to prevent a spurious click during startup. -Normally initializing to all zeros is sufficient. ``memset`` is a highly efficient way of doing this. - -Note, globally declared memory is always double word aligned. - - -.. _section_examples: - -Example Applications --------------------- - -Two stand alone applications showing the minimum code required to build a functioning -microphone array are given in ``AN00217_app_high_resolution_delay_example`` and in -``AN00220_app_phase_aligned_example``. - -A worked example of a fixed beam delay and sum beamformer is given in the application -``AN00219_app_lores_DAS_fixed``. Also examples of of how to set up high resolution delayed -sampling can be seen in the high resolution fixed beam delay and sum beamformer given -in the application ``AN00218_app_hires_DAS_fixed``. - -.. _section_dc: - -DC offset removal ------------------ - -The DC offset removal is implemented as a single pole IIR filer obeying the -relation:: - - Y[n] = Y[n-1] * alpha + x[n] - x[n-1] - -Where ``alpha`` is defined as ``1 - 2^MIC_ARRAY_DC_OFFSET_LOG2``. Increasing ``MIC_ARRAY_DC_OFFSET_LOG2`` -will increase the stability of the filter and decrease the cut off point at the cost of increased -settling time. Decreasing ``MIC_ARRAY_DC_OFFSET_LOG2`` will increase the cut off point of the filter. - - -Signal Characteristics ----------------------- - -Definition of terms -................... - -Passband -........ -This specifies the bandwidth, from DC, in Hz over which a signal will not be attenuated by more -than 3dB. - -Stopband -........ - -This specifies the start frequency to the input Nyquist sample rate that the input signal should -be attenuated over. - -.. _section_characteristics: - -Characteristics -............... - -By default the output signal has been decimated from the original PDM in such a way to introduce no more than --70dB of alias noise (during the decimation process) into the passband for all output sample rates. - - ======================== =================== ====================== - output_decimation_factor PDM Sample Rate(Hz) Output sample rate(Hz) - ======================== =================== ====================== - 2 3072000 48000 - 4 3072000 24000 - 6 3072000 16000 - 8 3072000 12000 - 12 3072000 8000 - 2 2822400 44100 - 4 2822400 22050 - 6 2822400 14700 - 8 2822400 11025 - 12 2822400 7350 - ======================== =================== ====================== - - ======================== ============ ============ ========== ========== - output_decimation_factor Passband(Hz) Stopband(Hz) Ripple(dB) THD+N(dB) - ======================== ============ ============ ========== ========== - 2 18240 24000 1.40 -144.63 - 4 10080 12480 0.49 -142.61 - 6 6720 8320 0.23 -139.10 - 8 5040 6240 0.18 -136.60 - 12 3360 4160 0.12 -133.07 - 2 16758 22050 1.40 -144.63 - 4 9261 11466 0.49 -142.61 - 6 6174 7644 0.23 -139.10 - 8 4630 5733 0.18 -136.60 - 12 3087 3822 0.12 -133.07 - ======================== ============ ============ ========== ========== - -The decimation is achieved by applying three poly-phase FIR filters sequentially. -The design of these filters can be viewed in the python script ``fir_design.py``. The default -magnitude responses of the first to third stages are given as :ref:`figthird_stage_div_2` -through to :ref:`figthird_stage_div_12` in the appendix. The first stage and second stage -can be viewed in :ref:`figfirst_stage` and :ref:`figsecond_stage`. - -Group delay -........... - -The group delay of the default filters is 18 output clock cycles. This can be shortened by either using a minimum phase -FIR as the final stage decimation FIR and/or by reducing the number of taps on the final stage decimation FIR. - -FIR dynamic range -................. - -The dynamic range of the decimation FIRs is given as ``(32 - log2(number of taps)) * 6.02``. This gives the first stage -at least 159.0dB of dynamic range, the second stage at least 168.6dB of dynamic range and the third stage with 32 -coefficients per phase as: - - ======================== ==================== - output_decimation_factor Dynamic Range (dB) - ======================== ==================== - 2 156.53 - 4 150.51 - 6 146.99 - 8 144.49 - 12 140.97 - ======================== ==================== - -.. _section_advanced: - -Advanced filter design ----------------------- - -The table in :ref:`section_characteristics` has been generated to provide 70dB of stopband attenuation for all decimation factors -whilst maintaining a fairly flat passband and wide bandwidth. However for a given specification -the filter characteristics can be optimised to reduce latency, increase passband, lower the -passband ripple and increase the signal to noise ratio. For example, in a system where a 16kHz -output is required then limiting the passband to 8kHz would improve the other properties. Equally, -if the noise floor of the PDM microphone is 65dB then there is little advantage exceeding that in the -filter. - -Note, as of version 3.0.0 the default FIR coefficients are optimised for 16kHz output with a stopband -attenuation of 70dB. Read below to specify custom filter characteristics. To see the exact filter characteristics -``fir_design.py`` can be run, as part of its output the script will write the filter characteristics to the terminal. - - -``fir_design.py`` usage -....................... - -In order generate custom filters the ``fir_design.py`` can be executed. The purpose of this script -is to design and generate the FIR coefficients for the three stages of decimation. ``fir_design.py`` -is a command line tool that takes a number of options to control each parameter of the -filter design. As previously illustrated the PDM to PCM conversion is divided into three stages. -The stop band attenuation is controlled for each stage with the options: - -* first stage (``--first-stage-stop-atten``) - The stop band attenuation(in dB) of the first stage filter(Normally negative). -* second stage (``--second-stage-stop-atten``) - The stop band attenuation(in dB) of the second stage filter(Normally negative). -* third stage (``--third-stage-stop-atten``) - The stop band attenuation(in dB) of the third stage filter(Normally negative). - -In the first stage the designer is then able to tune: - -* passband bandwidth (``--first-stage-pass-bw``) - The bandwidth of the passband, in kHz (defaults to 40kHz). -* stopband bandwidth (``--first-stage-stop-bw``) - The bandwidth of the bands around the regions that will alias with the pass band after decimation, in kHz. -* use lowest ripple first stage (``--use-low-ripple-first-stage``) - This uses an alternative filter design to minimise passband ripple at the cost of broadband stopband attenuation. -* num taps (``--first-stage-num-taps``) - Do not change this - -These are illustrated in :ref:`figfirst`. - - .. _figfirst: - .. figure:: first_stage_diagram.pdf - :width: 100% - - First stage design parameters. - -In the second stage the same options are available: - -* passband bandwidth (``--second-stage-pass-bw``) - The bandwidth of the passband, in kHz (defaults to 16kHz). -* stopband bandwidth (``--second-stage-stop-bw``) - The bandwidth of the bands around the regions that will alias with the pass band after decimation, in kHz. - -These are illustrated in :ref:`figsecond`. - - .. _figsecond: - .. figure:: second_stage_diagram.pdf - :width: 100% - - Second stage design parameters. - -In the third stage the designer can provide custom decimation factors in addition to the pass and stop band parameters. -Also the delay of the filter can be controlled by tuning the number of taps to allocate for each phase of -the poly-phase FIR (``--third-stage-num-taps``). The fewer the number of taps per phase then the shorter the -delay of the filter but the harder the design will be to meet other criteria. - -To add a custom third stage filter ``--add-third-stage`` has to be called. It requires the following arguments: - -* decimation factor - the ratio of input samples to output samples. -* output passband - this specifies where the passband ends. -* output stopband start - this specified where the stopband starts. -* filter_name - this assigns a name to the custom filter. -* num taps - the number of taps to use for each round of the third stage - -Examples -........ - -General Example -............... - -For example to add a third stage decimator called "my_filter" with a final stage decimation factor of D, -output passband of PkHz and output stopband start of S kHz and N taps per phase then the argument ``--add-third-stage D P S my_filter N`` -would need to be passed to the script. - -These are illustrated in figure :ref:`figthird`. - - .. _figthird: - .. figure:: third_stage_diagram.pdf - :width: 100% - - Third stage design parameters. - -The filter name is used to generate the defines and coefficient arrays used to implement the filter in ``lib_mic_array``. -The defines ``DECIMATION_FACTOR_ + (filter_name)`` and ``FIR_COMPENSATOR_ + (filter_name)`` will be generated to -represent the filter designed. In the generated defines the name will be in all caps and the FIR coefficients array will -be in all lowercase. Additionally, the array ``const int g_third_stage_ + (filter_name) _fir[]`` will -also be generated and will contain all the coefficients to implement the filter. -For example, if ``fir_design.py`` was passed the option ``--add-third-stage 2 P S my_filter N`` then available -in ``lib_mic_array`` would be:: - - #define DECIMATION_FACTOR_MY_FILTER (2) - #define FIR_COMPENSATOR_MY_FILTER (301451293) - extern const int g_third_stage_my_filter_fir[126]; - - -16kHz voice -........... - -In this example we would like to optimise for a 16kHz output rate, let's assume that the requirement of 6.7kHz bandwidth is sufficient. We will assume a 3.072MHz PDM clock and that our microphones have a -63dB SNR. This means that a decimation factor of 6 will be required to reduce the output of the second stage (384kHz in this case) down to 16kHz. We would also like to keep the passband ripple to within 0.15dB and have no aliasing in the highest frequencies above -40dB. - -Next we only require that each stage of decimation can pass the voice which, by virtue of the 16kHz sample rate, will be output limited to 8kHz of band width. The first decimator is by default over specified so needs no attention. The second stage decimator will introduce high frequency attenuation if the passband is too wide, for this reason we should limit it to our requirements in order to maximise stopband attenuation and minimise ripple. The third stage is where we make the final output decisions; we require 6.7kHz of passband bandwidth but in order to minimise ripple we want to relax the transition region as much as possible without introducing too much aliasing. In order to meet our specification we can set the start of the stop band at 8.15kHz and the stop band attenuation to -65dB. - -All this can be captured by the FIR design script:: - - python fir_design.py --pdm-sample-rate 3072 --second-stage-pass-bw 6.7 --second-stage-stop-bw 6.7 --add-third-stage 6 6.7 8.15 custom_voice 32 --third-stage-stop-atten -65.0 - -The resulting filter would be :ref:`figcustomvoice`. - - .. _figcustomvoice: - .. figure:: output_custom_voice.pdf - :width: 100% - - Custom voice filter. - -We can see that as the PDM sample rate was specified then the output magnitude response is displayed on :ref:`figcustomvoice`. - -48kHz fullband -.............. - -In this example we will look at the situation where a 48kHz wideband output is required. This time let's assume that a 14kHz passband is required with -70dB stop band attenuation and 0.3dB of ripple is acceptable. As the all of the default stopband -attenuations are better than or equal to the desired stopband attenuation then we wont need to modify it. We will need to set -the bandwidths of the second stage to our new 14kHz requirement. For the third stage tere will be no need for the stop band to exceed the Nyquist rate so we will set it to 24kHz. This can be captured by the FIR design script:: - - python fir_design.py --pdm-sample-rate 3072 --second-stage-pass-bw 14 --second-stage-stop-bw 14 --add-third-stage 6 14 24 custom_wideband 32 - -The resulting filter would be :ref:`figcustomwideband`. - - .. _figcustomwideband: - .. figure:: output_custom_wideband.pdf - :width: 100% - - Custom wideband filter. - -.. _section_api: - -API ---- - -Creating an PDM microphone interface instance -............................................. - -.. doxygenfunction:: mic_array_pdm_rx - -|newpage| - -PDM microphone processing -......................... - -.. doxygenfunction:: mic_array_decimate_to_pcm_4ch -.. doxygenfunction:: mic_array_decimator_configure -.. doxygenstruct:: mic_array_decimator_config_t -.. doxygenstruct:: mic_array_decimator_conf_common_t -.. doxygenfunction:: mic_array_init_far_end_channels -.. doxygenfunction:: mic_array_send_sample - -|newpage| - -PCM frame interfacing -..................... - -.. doxygenenum:: mic_array_decimator_buffering_t -.. doxygenfunction:: mic_array_init_time_domain_frame -.. doxygenfunction:: mic_array_get_next_time_domain_frame -.. doxygenfunction:: mic_array_init_frequency_domain_frame -.. doxygenfunction:: mic_array_get_next_frequency_domain_frame - -|newpage| - -Frame types -........... - -.. doxygenstruct:: mic_array_frame_time_domain -.. doxygenstruct:: mic_array_frame_frequency_domain -.. doxygenstruct:: mic_array_frame_fft_preprocessed -.. doxygenstruct:: mic_array_metadata_t - -High resolution delay task -.......................... - -.. doxygenfunction:: mic_array_hires_delay -.. doxygenfunction:: mic_array_hires_delay_set_taps - -|newpage| -|appendix| - - -.. _figfirst_stage: -.. figure:: first_stage.pdf - :width: 70% - - First stage FIR magnitude response. - - -.. _figsecond_stage: -.. figure:: second_stage.pdf - :width: 70% - - Second stage FIR magnitude response. - - -.. _figthird_stage_div_2: -.. figure:: third_stage_div_2.pdf - :width: 70% - - Third stage FIR magnitude response for a divide of 2 giving a typical output rate of 48kHz(3.072MHz) or 44.1kHz(2.8224MHz). - - -.. _figthird_stage_div_4: -.. figure:: third_stage_div_4.pdf - :width: 70% - - Third stage FIR magnitude response for a divide of 4 giving a typical output rate of 24kHz(3.072MHz) or 22.05kHz(2.8224MHz). - - -.. _figthird_stage_div_6: -.. figure:: third_stage_div_6.pdf - :width: 70% - - Third stage FIR magnitude response for a divide of 6 giving a typical output rate of 16kHz(3.072MHz) or 14.7kHz(2.8224MHz). - - -.. _figthird_stage_div_8: -.. figure:: third_stage_div_8.pdf - :width: 70% - - Third stage FIR magnitude response for a divide of 8 giving a typical output rate of 12kHz(3.072MHz) or 11.025kHz(2.8224MHz). - - -.. _figthird_stage_div_12: -.. figure:: third_stage_div_12.pdf - :width: 70% - - Third stage FIR magnitude response for a divide of 12 giving a typical output rate of 8kHz(3.072MHz) or 7.35kHz(2.8224MHz). - - - -.. _figouput_div_2: -.. figure:: output_div_2.pdf - :width: 70% - - Final frequency response for a divide of 2 giving a typical output rate of 48kHz(3.072MHz) or 44.1kHz(2.8224MHz). - - - -.. _figouput_div_4: -.. figure:: output_div_4.pdf - :width: 70% - - Final frequency response for a divide of 4 giving a typical output rate of 24kHz(3.072MHz) or 22.05kHz(2.8224MHz). - - - -.. _figouput_div_6: -.. figure:: output_div_6.pdf - :width: 70% - - Final frequency response for a divide of 6 giving a typical output rate of 16kHz(3.072MHz) or 14.7kHz(2.8224MHz). - - - -.. _figouput_div_8: -.. figure:: output_div_8.pdf - :width: 70% - - Final frequency response for a divide of 8 giving a typical output rate of 12kHz(3.072MHz) or 11.025kHz(2.8224MHz). - - - -.. _figouput_div_12: -.. figure:: output_div_12.pdf - :width: 70% - - Final frequency response for a divide of 12 giving a typical output rate of 8kHz(3.072MHz) or 7.35kHz(2.8224MHz). - - -|newpage| - -Known Issues ------------- - - * decimator_config channel count is tested for 4 channels per decimator, fewer than 4 is untested. - -.. include:: ../../../CHANGELOG.rst diff --git a/lib_mic_array/doc/rst/memory_layout.pdf b/lib_mic_array/doc/rst/memory_layout.pdf deleted file mode 100644 index b0698988..00000000 Binary files a/lib_mic_array/doc/rst/memory_layout.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/memory_layout.svg b/lib_mic_array/doc/rst/memory_layout.svg deleted file mode 100644 index 45671023..00000000 --- a/lib_mic_array/doc/rst/memory_layout.svg +++ /dev/null @@ -1,1998 +0,0 @@ - - - - - - - - - - image/svg+xml - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Simple Audio Frames - Channel - 0 - 1 - 2 - 3 - … - 13 - 14 - 15 - Sample Index - Oldest - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 2 - 2 - 2 - 2 - 2 - 2 - 2 - … - … - … - … - … - … - … - 125 - 125 - 125 - 125 - 125 - 125 - 125 - 126 - 126 - 126 - 126 - 126 - 126 - 126 - Newest - 127 - 127 - 127 - 127 - 127 - 127 - 127 - Complex Audio Frames - Channel - 0 - 1 - … - 7 - Real - Imaginary - Real - Imaginary - Real - Imaginary - Real - Imaginary - Oldest - 0 - 0 - 0 - 0 - 0 - 0 - Sample Index - 1 - 1 - 1 - 1 - 1 - 1 - 2 - 2 - 2 - 2 - 2 - 2 - … - … - … - … - … - … - 125 - 125 - 125 - 125 - 125 - 125 - 126 - 126 - 126 - 126 - 126 - 126 - Newest - 127 - 127 - 127 - 127 - 127 - 127 - - diff --git a/lib_mic_array/doc/rst/output_custom_voice.pdf b/lib_mic_array/doc/rst/output_custom_voice.pdf deleted file mode 100644 index b48d1717..00000000 Binary files a/lib_mic_array/doc/rst/output_custom_voice.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/output_custom_wideband.pdf b/lib_mic_array/doc/rst/output_custom_wideband.pdf deleted file mode 100644 index 451b8d0e..00000000 Binary files a/lib_mic_array/doc/rst/output_custom_wideband.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/output_div_12.pdf b/lib_mic_array/doc/rst/output_div_12.pdf deleted file mode 100644 index 508ced08..00000000 Binary files a/lib_mic_array/doc/rst/output_div_12.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/output_div_2.pdf b/lib_mic_array/doc/rst/output_div_2.pdf deleted file mode 100644 index 8e338f2a..00000000 Binary files a/lib_mic_array/doc/rst/output_div_2.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/output_div_4.pdf b/lib_mic_array/doc/rst/output_div_4.pdf deleted file mode 100644 index c2043dad..00000000 Binary files a/lib_mic_array/doc/rst/output_div_4.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/output_div_6.pdf b/lib_mic_array/doc/rst/output_div_6.pdf deleted file mode 100644 index 31c7c809..00000000 Binary files a/lib_mic_array/doc/rst/output_div_6.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/output_div_8.pdf b/lib_mic_array/doc/rst/output_div_8.pdf deleted file mode 100644 index 9d99fa50..00000000 Binary files a/lib_mic_array/doc/rst/output_div_8.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/second_stage.pdf b/lib_mic_array/doc/rst/second_stage.pdf deleted file mode 100644 index dbff7b2e..00000000 Binary files a/lib_mic_array/doc/rst/second_stage.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/second_stage_diagram.pdf b/lib_mic_array/doc/rst/second_stage_diagram.pdf deleted file mode 100644 index 7e8836c0..00000000 Binary files a/lib_mic_array/doc/rst/second_stage_diagram.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/second_stage_diagram.svg b/lib_mic_array/doc/rst/second_stage_diagram.svg deleted file mode 100644 index 8c4ea45c..00000000 --- a/lib_mic_array/doc/rst/second_stage_diagram.svg +++ /dev/null @@ -1,719 +0,0 @@ - - - -image/svg+xml0.0 -0.1 -0.2 -0.3 -0.4 -Normalised Input Freq (i.e. 384kHz or 352.8kHz) -−160 -−140 -−120 -−100 -−80 -−60 -−40 -−20 -0 -20 -Magnitude Response -0.5 -Stopband -Stopband -Stopband -Passband -PassbandBandwidth -StopbandBandwidth -StopbandAttenuation - \ No newline at end of file diff --git a/lib_mic_array/doc/rst/state_machine.dot b/lib_mic_array/doc/rst/state_machine.dot deleted file mode 100755 index 10bfec8c..00000000 --- a/lib_mic_array/doc/rst/state_machine.dot +++ /dev/null @@ -1,24 +0,0 @@ -digraph g { - - program_start [label="Program start"]; - - decimator_configure [label="mic_array_decimator_configure()"]; - decimator_init_audio [label="mic_array_init_time_domain_frame()"]; - decimator_get_next_audio_frame [label="mic_array_get_next_time_domain_frame"]; - decimator_init_complex [label="mic_array_init_frequency_domain_frame()"]; - decimator_get_next_complex_frame [label="mic_array_get_next_frequency_domain_frame"]; - - program_start -> decimator_configure; - - decimator_configure -> decimator_init_audio; - decimator_configure -> decimator_init_complex; - - decimator_init_audio -> decimator_get_next_audio_frame; - decimator_get_next_audio_frame -> decimator_get_next_audio_frame; - decimator_get_next_audio_frame -> decimator_configure - - - decimator_init_complex -> decimator_get_next_complex_frame; - decimator_get_next_complex_frame -> decimator_get_next_complex_frame; - decimator_get_next_complex_frame -> decimator_configure -} diff --git a/lib_mic_array/doc/rst/state_machine.pdf b/lib_mic_array/doc/rst/state_machine.pdf deleted file mode 100644 index 869adeab..00000000 Binary files a/lib_mic_array/doc/rst/state_machine.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/third_stage_diagram.pdf b/lib_mic_array/doc/rst/third_stage_diagram.pdf deleted file mode 100644 index 114a57b1..00000000 Binary files a/lib_mic_array/doc/rst/third_stage_diagram.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/third_stage_diagram.svg b/lib_mic_array/doc/rst/third_stage_diagram.svg deleted file mode 100644 index 9e25b8c6..00000000 --- a/lib_mic_array/doc/rst/third_stage_diagram.svg +++ /dev/null @@ -1,702 +0,0 @@ - - - -image/svg+xml0.0 -0.1 -0.2 -0.3 -0.4 -Normalised Input Freq (i.e. 96kHz or 88.2kHz) -−160 -−140 -−120 -−100 -−80 -−60 -−40 -−20 -0 -20 -Magnitude Response -0.5 -Stopband -Passband -Cut Off -Cut Off -StopbandAttenuation - \ No newline at end of file diff --git a/lib_mic_array/doc/rst/third_stage_div_12.pdf b/lib_mic_array/doc/rst/third_stage_div_12.pdf deleted file mode 100644 index b80fd6cd..00000000 Binary files a/lib_mic_array/doc/rst/third_stage_div_12.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/third_stage_div_2.pdf b/lib_mic_array/doc/rst/third_stage_div_2.pdf deleted file mode 100644 index 0df70391..00000000 Binary files a/lib_mic_array/doc/rst/third_stage_div_2.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/third_stage_div_4.pdf b/lib_mic_array/doc/rst/third_stage_div_4.pdf deleted file mode 100644 index f420be68..00000000 Binary files a/lib_mic_array/doc/rst/third_stage_div_4.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/third_stage_div_6.pdf b/lib_mic_array/doc/rst/third_stage_div_6.pdf deleted file mode 100644 index 3086cd62..00000000 Binary files a/lib_mic_array/doc/rst/third_stage_div_6.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/third_stage_div_8.pdf b/lib_mic_array/doc/rst/third_stage_div_8.pdf deleted file mode 100644 index 37920808..00000000 Binary files a/lib_mic_array/doc/rst/third_stage_div_8.pdf and /dev/null differ diff --git a/lib_mic_array/doc/rst/xdoc.conf b/lib_mic_array/doc/rst/xdoc.conf deleted file mode 100644 index 7b145765..00000000 --- a/lib_mic_array/doc/rst/xdoc.conf +++ /dev/null @@ -1,2 +0,0 @@ -XMOSNEWSTYLE = 1 -DOXYGEN_DIRS=../../api \ No newline at end of file diff --git a/lib_mic_array/module_build_info b/lib_mic_array/module_build_info index 4fe0bcd5..a184a275 100644 --- a/lib_mic_array/module_build_info +++ b/lib_mic_array/module_build_info @@ -1,19 +1,30 @@ -VERSION = 4.5.0 - -DEPENDENT_MODULES = lib_xassert(>=4.0.0) \ - lib_logging(>=3.0.0) \ - lib_dsp(>=6.0.0) - -MODULE_XCC_FLAGS = $(XCC_FLAGS) - -OPTIONAL_HEADERS += - -EXPORT_INCLUDE_DIRS = api \ - src/fir - -EXCLUDE_FILES += make_mic_dual_stage_3_coefs.c - -INCLUDE_DIRS = $(EXPORT_INCLUDE_DIRS) - -SOURCE_DIRS = src \ - src/fir +VERSION = 5.0.2 + +DEPENDENT_MODULES = lib_xcore_math + +MODULE_XCC_FLAGS = $(XCC_FLAGS) -g -Os + +# there is no MODULE_XCC_CPP_FLAGS +# MODULE_XCC_CPP_FLAGS = -std=c++11 +XCC_FLAGS_Util.cpp = -std=c++11 $(XCC_FLAGS) + +INCLUDE_DIRS = api + + +SOURCE_DIRS = src \ + src/etc + +# If using xmake/module_build_info instead of cmake, the vanilla API can still +# be used by setting VANILLA_API_ENABLED to 1 in your application Makefile. +# This also requires the following compile definitions to be added for your +# application (see /etc/vanilla/vanilla.cmake): +# MIC_ARRAY_CONFIG_MCLK_FREQ # Master audio clock frequency +# MIC_ARRAY_CONFIG_PDM_FREQ # PDM clock frequency +# MIC_ARRAY_CONFIG_MIC_COUNT # Number of microphones +# MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME # Number of samples in each frame of +# # audio delivered by the mic array. +ifeq (1, $(VANILLA_API_ENABLED)) +SOURCE_DIRS += ../etc/vanilla +INCLUDE_DIRS += ../etc/vanilla +XCC_FLAGS_mic_array_vanilla.cpp = -std=c++11 $(XCC_FLAGS) +endif \ No newline at end of file diff --git a/lib_mic_array/module_description b/lib_mic_array/module_description deleted file mode 100644 index a1f4cb4b..00000000 --- a/lib_mic_array/module_description +++ /dev/null @@ -1 +0,0 @@ -Microphone array library \ No newline at end of file diff --git a/lib_mic_array/src/Util.cpp b/lib_mic_array/src/Util.cpp new file mode 100644 index 00000000..b6921e76 --- /dev/null +++ b/lib_mic_array/src/Util.cpp @@ -0,0 +1,58 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "mic_array/cpp/Util.hpp" +#include "mic_array/util.h" + +#include "mic_array.h" + + + +template <> +void mic_array::deinterleave_pdm_samples<1>( + uint32_t* samples, + unsigned s2_dec_factor) +{ + //Nothing to do for 1 mic +} + +template <> +void mic_array::deinterleave_pdm_samples<2>( + uint32_t* samples, + unsigned s2_dec_factor) +{ + constexpr unsigned MICS = 2; + + for(int k = 0; k < s2_dec_factor; k++) { + uint32_t* sb = &samples[k*MICS]; + deinterleave2(sb); + } +} + +template <> +void mic_array::deinterleave_pdm_samples<4>( + uint32_t* samples, + unsigned s2_dec_factor) +{ + constexpr unsigned MICS = 4; + + for(int k = 0; k < s2_dec_factor; k++) { + uint32_t* sb = &samples[k*MICS]; + deinterleave4(sb); + } +} + + + +template <> +void mic_array::deinterleave_pdm_samples<8>( + uint32_t* samples, + unsigned s2_dec_factor) +{ + constexpr unsigned MICS = 8; + + for(int k = 0; k < s2_dec_factor; k++) { + uint32_t* sb = &samples[k*MICS]; + deinterleave8(sb); + } +} \ No newline at end of file diff --git a/lib_mic_array/src/dc_elimination.c b/lib_mic_array/src/dc_elimination.c new file mode 100644 index 00000000..887cb701 --- /dev/null +++ b/lib_mic_array/src/dc_elimination.c @@ -0,0 +1,37 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "mic_array/dc_elimination.h" + +#include + +void dcoe_state_init( + dcoe_chan_state_t state[], + const unsigned chan_count) +{ + memset(state, 0, sizeof(dcoe_chan_state_t) * chan_count); +} + +void dcoe_filter( + int32_t new_output[], + dcoe_chan_state_t state[], + int32_t new_input[], + const unsigned chan_count) +{ + #define N 32 + #define Q 8 + + for(int k = 0; k < chan_count; k++){ + const int64_t x_new = ((int64_t)new_input[k]) << N; + state[k].prev_y += x_new; + new_output[k] = state[k].prev_y >> N; + // Doing these next two steps here avoids the need to store the + // inputs between samples + state[k].prev_y = state[k].prev_y - (state[k].prev_y >> Q); + state[k].prev_y = state[k].prev_y - x_new; + + } + + #undef N + #undef Q +} diff --git a/lib_mic_array/src/decimate_to_pcm_4ch.S b/lib_mic_array/src/decimate_to_pcm_4ch.S deleted file mode 100644 index 6f0f2635..00000000 --- a/lib_mic_array/src/decimate_to_pcm_4ch.S +++ /dev/null @@ -1,1379 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. - .section .dp.data,"awd",@progbits - .text - -#include "mic_array_conf.h" - -#define USE_SINGLE_CHAN_SAVING 0 - -#ifndef MIC_ARRAY_MAX_FRAME_SIZE_LOG2 - #error MIC_ARRAY_MAX_FRAME_SIZE_LOG2 is not defined in mic_array_conf.h -#endif - -#ifndef MIC_ARRAY_DC_OFFSET_LOG2 - #define MIC_ARRAY_DC_OFFSET_LOG2 8 -#endif - -#ifndef MIC_ARRAY_FIXED_GAIN - #define MIC_ARRAY_FIXED_GAIN 0 //x 6.02db. Apply a fixed gain to the outputs -#endif - -.xtacommand "analyse endpoints input_0_0_ep input_1_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_1_0_ep input_2_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_2_0_ep input_3_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_3_0_ep input_4_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_4_0_ep input_5_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_5_0_ep input_6_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_6_0_ep input_7_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_7_0_ep input_0_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_0_1_ep input_1_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_1_1_ep input_2_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_2_1_ep input_3_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_3_1_ep input_4_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_4_1_ep input_5_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_5_1_ep input_6_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_6_1_ep input_7_1_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints input_7_1_ep input_0_0_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ - -#define SECOND_STAGE_COEF_COUNT 16 //This must reflect the implementation in mic_array_decimate_to_pcm_4ch_fir_impl -#define THIRD_STAGE_COEFS_PER_STAGE 32 //This must reflect the implementation in third_stage_fir_impl -#define THIRD_STAGE_COEFS_PER_ROW 63 //This must reflect the implementation in third_stage_fir_impl -#define MAX_DECIMATION_FACTOR 12 - -//derived defines -#define SECOND_STAGE_BUFFER_SIZE (SECOND_STAGE_COEF_COUNT*2) - -////////////////////////////////////////////////////////////////////////////////////// - -//This stuff is at the start of the stack for really quick access -#define S_STORAGE 0 - -#define S_UNUSED 0 -#define S_C_INPUT 1 - -#define S_C_OUTPUT 2 -#define S_CHAN_COUNT 3 - -#define S_D_DC_OFFSET_LOG2_CH01 2 -#define S_D_DC_OFFSET_LOG2_CH23 3 - -#define S_DC_OFFSET_LOG2_CH0 4 -#define S_DC_OFFSET_LOG2_CH1 5 -#define S_DC_OFFSET_LOG2_CH2 6 -#define S_DC_OFFSET_LOG2_CH3 7 - -#define S_DC_OFFSET_SAMPLE_NO 8 - -#define S_FIR_GAIN_COMP 9 - -#define S_FAR_END_CHANNEL_0 10 -#define S_FAR_END_CHANNEL_1 11 -#define S_FAR_END_CHANNEL_2 12 -#define S_FAR_END_CHANNEL_3 13 - -#define S_ASYNC_INTERFACE 14 - -#define S_STORAGE_SIZE 16 - -////////////////////////////////////////////////////////////////////////////////////// -//this address must be double word aligned -#define S_SECOND_STAGE_DATA (S_STORAGE + S_STORAGE_SIZE) -#define S_SECOND_STAGE_DATA_SIZE (16*2*4) //16 words by 2 blocks by 4 channels - -////////////////////////////////////////////////////////////////////////////////////// - -#define S_THIRD_STAGE (S_SECOND_STAGE_DATA + S_SECOND_STAGE_DATA_SIZE) - -#define S_D_THIRD_STAGE_PHASE_AND_COUNT 0 //0 1 - //2 3 -#define S_D_THIRD_STAGE_POINTERS 1 //4 5 -#define S_D_THIRD_STAGE_CH0_ACC 3 //6 7 -#define S_D_THIRD_STAGE_CH1_ACC 4 //8 9 -#define S_D_THIRD_STAGE_CH2_ACC 5 //10 11 -#define S_D_THIRD_STAGE_CH3_ACC 6 //12 13 - -#define S_THIRD_STAGE_PHASE 0 //need to be 0-11 for divide_by_four -#define S_THIRD_STAGE_PHASE_COUNT 1 -#define S_THIRD_STAGE_DATA_POINTER 2 -#define S_THIRD_STAGE_COEFS_POINER 3 -#define S_THIRD_STAGE_COEFS_PHASE 4 -#define S_THIRD_STAGE_UNUSED 5 -#define S_THIRD_STAGE_SIZE (16) - -////////////////////////////////////////////////////////////////////////////////////// - -#define S_OUTPUT_STORAGE (S_THIRD_STAGE+S_THIRD_STAGE_SIZE) -#define S_D_OUTPUT_STORAGE_01 0 -#define S_D_OUTPUT_STORAGE_23 1 -#define S_OUTPUT_STORAGE_SIZE 4 - -////////////////////////////////////////////////////////////////////////////////////// - -//Note: this will survive a reconfig -#define S_DC_ELIMINATE (S_OUTPUT_STORAGE+S_OUTPUT_STORAGE_SIZE) -#define S_PREV_X_0 0 -#define S_PREV_X_1 1 -#define S_PREV_X_2 2 -#define S_PREV_X_3 3 - -#define S_D_PREV_X_01 0 -#define S_D_PREV_X_23 1 -#define S_D_PREV_Y_0 2 -#define S_D_PREV_Y_1 3 -#define S_D_PREV_Y_2 4 -#define S_D_PREV_Y_3 5 -#define DC_ELIMINATE_STACK_SIZE 12 - -//frame -#define S_FRAME_OFFSET (S_DC_ELIMINATE + DC_ELIMINATE_STACK_SIZE) -#define S_D_FRAME_POINTER_AND_INDEX_0 3 -#define S_D_FRAME_POINTER_AND_INDEX_1 4 -#define S_D_FRAME_NO_OVERLAPPING 1 -#define S_D_METADATA_POINTERS 2 -#define S_FRAME_GAIN 0 //this is the current gain on the frame -#define S_FRAME_SIZE_LOG2 1 //this is the current frame size log2 -#define S_FRAME_NUMBER 2 //should this be presistant between configs? -#define S_OVERLAPPING_FRAMES 3 //0 for on overlap, 1 for overlapping -#define S_METADATA_POINTER_0 4 -#define S_METADATA_POINTER_1 5 -#define S_FRAME_POINTER_0 6 //pointer to the current frame -#define S_FRAME_0_INDEX 7 //index to write to the current frame -#define S_FRAME_POINTER_1 8 //pointer to the next frame -#define S_FRAME_1_INDEX 9 //index to write to the next frame -#define S_FRAME_SIZE 10 //this is the current frame size log2 -#define FRAME_STACK_SIZE 12 - -#define S_MIC_CALIB_OFFSET (S_FRAME_OFFSET+FRAME_STACK_SIZE) -#define S_MIC_CALIB_0 0 -#define S_MIC_CALIB_1 1 -#define S_D_MIC_CALIB_01 0 -#define S_MIC_CALIB_2 2 -#define S_MIC_CALIB_3 3 -#define S_D_MIC_CALIB_23 1 -#define MIC_CALIB_STACK_SIZE 4 - -#define S_SETTINGS_OFFSET (S_MIC_CALIB_OFFSET+MIC_CALIB_STACK_SIZE) -#define S_WINDOWING_ENABLED 0 //0 for disabled, pointer for enabled -#define S_INDEX_BITREVERSING_ENABLED 1 -#define S_DC_OFFSET_REMOVAL_ENABLED 2 -#define S_DECIMATION_FACTOR_is_now_S_THIRD_STAGE_PHASE_COUNT 3 -#define S_MIC_GAIN_COMP 4 -#define S_SETTINGS_SIZE 6 - -//This must be an even number -#define STACKWORDS (S_SETTINGS_OFFSET + S_SETTINGS_SIZE) - -//This is used for commenting within marcos -#define comment(X) - -//TODO - use this when everything works -//TODO then reduce the memory usage -//Note: there could be two implementations of this where one never writes to -//memory 28-32 as they are never used -#define INPUT_TO_OFFSET_12_15(OFFSET) \ - ldw r1, sp[S_C_INPUT]; \ - in r0, res[r1];\ - {stw r0, dp[0*SECOND_STAGE_BUFFER_SIZE + OFFSET]; in r0, res[r1]};\ - {stw r0, dp[1*SECOND_STAGE_BUFFER_SIZE + OFFSET]; in r0, res[r1]};\ - stw r0, dp[2*SECOND_STAGE_BUFFER_SIZE + OFFSET];\ - in r0, res[r1];\ - {stw r0, dp[3*SECOND_STAGE_BUFFER_SIZE + OFFSET]} - -//This inputs from the channel to the pdm interface and saves it twice in the -//second stage FIR at offset OFFSET and OFFSET + 16 -#define INPUT_TO_OFFSET(OFFSET) \ - ldw r1, sp[S_C_INPUT]; \ - in r0, res[r1];\ - {stw r0, dp[0*SECOND_STAGE_BUFFER_SIZE + OFFSET]};\ - {stw r0, dp[0*SECOND_STAGE_BUFFER_SIZE + SECOND_STAGE_COEF_COUNT + OFFSET]; in r0, res[r1]};\ - {stw r0, dp[1*SECOND_STAGE_BUFFER_SIZE + OFFSET]};\ - {stw r0, dp[1*SECOND_STAGE_BUFFER_SIZE + SECOND_STAGE_COEF_COUNT + OFFSET]; in r0, res[r1]};\ - {stw r0, dp[2*SECOND_STAGE_BUFFER_SIZE + OFFSET]};\ - {stw r0, dp[2*SECOND_STAGE_BUFFER_SIZE + SECOND_STAGE_COEF_COUNT + OFFSET]};\ - in r0, res[r1];\ - {stw r0, dp[3*SECOND_STAGE_BUFFER_SIZE + OFFSET]};\ - {stw r0, dp[3*SECOND_STAGE_BUFFER_SIZE + SECOND_STAGE_COEF_COUNT + OFFSET]} - - -//setup divider by N registers (coefs, data, accumulators) -//must avoid r0 and r1 for persistant state as they will be clobbered by INPUT_TO_OFFSET - //coef = coef[THIRD_STAGE_COEFS_PER_STAGE-1] ---this is done offline - //coef = coef[THIRD_STAGE_COEFS_PER_ROW*S_THIRD_STAGE_PHASE - S_THIRD_STAGE_COEFS_PHASE] - //data0 = data[THIRD_STAGE_COEFS_PER_STAGE*S_THIRD_STAGE_PHASE*4] - //data1 = data0[THIRD_STAGE_COEFS_PER_STAGE] -#define DIVIDE_BY_N_0()\ - ldaw r0, sp[S_THIRD_STAGE];\ - {ldw r7, r0[S_THIRD_STAGE_PHASE]; ldc r6, THIRD_STAGE_COEFS_PER_ROW};\ - mul r6, r6, r7;\ - {ldw r5, r0[S_THIRD_STAGE_COEFS_PHASE]; ldc r8, THIRD_STAGE_COEFS_PER_STAGE};\ - {sub r6, r6, r5; ldw r9, r0[S_THIRD_STAGE_COEFS_POINER]};\ - ldaw r9, r9[r6];\ - mul r7, r7, r8;\ - ldw r6, sp[S_CHAN_COUNT];\ - mul r7, r7, r6;\ - ldw r10, r0[S_THIRD_STAGE_DATA_POINTER];\ - ldaw r10, r10[r7];\ - ldaw r11, r10[r8];\ - ldd r8, r7, r0[S_D_THIRD_STAGE_CH0_ACC];\ - ldd r6, r5, r0[S_D_THIRD_STAGE_CH1_ACC];\ - bl third_stage_fir_impl;\ - ldaw r0, sp[S_THIRD_STAGE];\ - std r8, r7, r0[S_D_THIRD_STAGE_CH0_ACC];\ - std r6, r5, r0[S_D_THIRD_STAGE_CH1_ACC] - -#define N_DIVIDE_BY_N_1()\ - {ldc r0, THIRD_STAGE_COEFS_PER_STAGE};\ - ldaw r9, r9[-r0];\ - ldc r0, THIRD_STAGE_COEFS_PER_STAGE-24;\ - ldaw r10, r11[r0];\ - {ldc r0, THIRD_STAGE_COEFS_PER_STAGE};\ - ldaw r11, r10[r0];\ - ldaw r0, sp[S_THIRD_STAGE];\ - ldd r8, r7, r0[S_D_THIRD_STAGE_CH2_ACC];\ - ldd r6, r5, r0[S_D_THIRD_STAGE_CH3_ACC];\ - bl third_stage_fir_impl;\ - ldaw r0, sp[S_THIRD_STAGE];\ - std r8, r7, r0[S_D_THIRD_STAGE_CH2_ACC];\ - std r6, r5, r0[S_D_THIRD_STAGE_CH3_ACC] - -#define DC_OFFSET_REMOVAL(PREV_Y, PREV_X, REGISTER) \ - ldd r6, r5, r4[PREV_Y];\ - ldc r7, MIC_ARRAY_DC_OFFSET_LOG2;\ - ashr r9, r6, r7;\ - lextract r8, r6, r5, r7, 32;\ - lsub r11, r5, r5, r8, r4; comment(using the lowest bit of r4 which is always 0) \ - lsub r11, r6, r6, r9, r11; \ - {ldw r7, r4[PREV_X]};\ - ashr r9, REGISTER, 32;\ - ashr r10, r7, 32;\ - lsub r11, r8, REGISTER, r7, r4; comment(same here) \ - lsub r11, r9, r9, r10, r11;\ - {ldc r10, 16};\ - lextract r9, r9, r8, r10, 32;\ - {shl r8, r8, r10; stw REGISTER, r4[PREV_X]};\ - lsub r11, r5, r5, r8, r4; comment(same here) \ - lsub r11, r6, r6, r9, r11;\ - std r6, r5, r4[PREV_Y];\ - lextract REGISTER, r6, r5, r10, 32 - -//r6 is the AUDIO_POINTER_INDEX --note that on the second pass r0-r3 will need to be reloaded as this modified them -#define APPLY_WINDOW_FN(P)\ - ldaw r9, sp[S_SETTINGS_OFFSET];\ - ldw r9, r9[S_WINDOWING_ENABLED];\ - bf r9, done_windowing ## P;\ - apply_windowing ## P:;\ - ldw r5, r4[S_FRAME_SIZE_LOG2];\ - {shl r5, r6, 1; mkmsk r8, r5};\ - {lss r5, r8, r5; ldc r7, 31};\ - {bf r5, skip ## P ; mov r4, r6};\ - sub r4, r8, r6;\ - skip ## P:;\ - {ldc r10, 0; ldc r11, 0};\ - {ldw r4, r9[r4]};\ - maccs r10, r11, r4, r0;\ - lextract r0, r10, r11, r7, 32;\ - {ldc r10, 0; ldc r11, 0};\ - maccs r10, r11, r4, r1;\ - lextract r1, r10, r11, r7, 32;\ - {ldc r10, 0; ldc r11, 0};\ - maccs r10, r11, r4, r2;\ - lextract r2, r10, r11, r7, 32;\ - {ldc r10, 0; ldc r11, 0};\ - maccs r10, r11, r4, r3;\ - lextract r3, r10, r11, r7, 32;\ - done_windowing ## P: - -//r4 is the address of the S_FRAME_OFFSET_SECTION -//r6 is the AUDIO_POINTER_INDEX -#if MIC_ARRAY_WORD_LENGTH_SHORT - #define SAVE_SAMPLES_BIT_REVERSED(POINTER)\ - {ldw r5, r4[S_FRAME_SIZE_LOG2]; ldc r7, 32};\ - {bitrev r6, r6; ldc r8, 2};\ - {sub r9, r7, r5;ldw r11, sp[S_CHAN_COUNT]};\ - {lsu r11, r8, r11 ;ldc r8, (MIC_ARRAY_MAX_FRAME_SIZE_LOG2+2)};\ - {shl r8, r11, r8;ldw r7, r4[POINTER] };\ - {add r8, r7, r8;shr r6, r6, r9;};\ - {shr r0, r0, 16; shr r1, r1, 16};\ - {shr r2, r2, 16; shr r3, r3, 16};\ - {shl r1, r1, 16; shl r3, r3, 16};\ - {add r1, r1, r0; add r3, r3, r2};\ - stw r3, r8[r6];\ - stw r1, r7[r6] - -#else - #define SAVE_SAMPLES_BIT_REVERSED(POINTER)\ - {ldw r5, r4[S_FRAME_SIZE_LOG2]; ldc r7, 32};\ - {bitrev r6, r6; ldc r8, 2};\ - {sub r9, r7, r5;ldw r11, sp[S_CHAN_COUNT]};\ - {lsu r11, r8, r11 ;ldc r8, (MIC_ARRAY_MAX_FRAME_SIZE_LOG2+3)};\ - {shl r8, r11, r8;ldw r7, r4[POINTER] };\ - {add r8, r7, r8;shr r6, r6, r9;};\ - std r3, r2, r8[r6];\ - std r1, r0, r7[r6] - -#endif - -//r4 is the address of the S_FRAME_OFFSET_SECTION -//r6 is the AUDIO_POINTER_INDEX -#if MIC_ARRAY_WORD_LENGTH_SHORT - #define SAVE_SAMPLES_PACKED(POINTER)\ - {ldc r8, 2 ;ldw r11, sp[S_CHAN_COUNT]};\ - {lsu r11, r8, r11 ;ldc r8, (MIC_ARRAY_MAX_FRAME_SIZE_LOG2+2)};\ - {shl r8, r11, r8;ldw r7, r4[POINTER] };\ - {add r8, r7, r8; nop};\ - {shr r0, r0, 16; shr r1, r1, 16};\ - {shr r2, r2, 16; shr r3, r3, 16};\ - {shl r1, r1, 16; shl r3, r3, 16};\ - {add r1, r1, r0; add r3, r3, r2};\ - stw r3, r8[r6];\ - stw r1, r7[r6] - -#else - #define SAVE_SAMPLES_PACKED(POINTER)\ - {ldc r8, 2 ; ldw r11, sp[S_CHAN_COUNT]};\ - {lsu r11, r8, r11 ;ldc r8, (MIC_ARRAY_MAX_FRAME_SIZE_LOG2+3)};\ - {shl r8, r11, r8;ldw r7, r4[POINTER] };\ - {add r8, r7, r8; nop};\ - std r3, r2, r8[r6];\ - std r1, r0, r7[r6] - -#endif - -//r4 is the address of the S_FRAME_OFFSET_SECTION -//r6 is the AUDIO_POINTER_INDEX -#if MIC_ARRAY_WORD_LENGTH_SHORT - #define SAVE_SAMPLES_NORMAL(POINTER, N)\ - {ldc r5, 1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2)};\ - {add r7, r6, r5; ldw r8, r4[POINTER]};\ - {add r5, r5, r5};\ - {shr r0, r0, 16; shr r1, r1, 16};\ - {shr r2, r2, 16; shr r3, r3, 16};\ - st16 r1, r8[r7];\ - st16 r0, r8[r6];\ - {add r7, r7, r5; add r6, r6, r5};\ - st16 r3, r8[r7];\ - st16 r2, r8[r6] - -#else - #define SAVE_SAMPLES_NORMAL(POINTER, N)\ - {ldc r5, 1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2)};\ - {add r7, r6, r5; ldw r8, r4[POINTER]};\ - {add r5, r5, r5};\ - stw r1, r8[r7];\ - stw r0, r8[r6];\ - {add r7, r7, r5; add r6, r6, r5};\ - stw r3, r8[r7];\ - stw r2, r8[r6] - -#endif - - - -#define SETUP_INTERNAL_CHANNEL(ID)\ - ldw r3, r2[ID];\ - stw r3, sp[S_FAR_END_CHANNEL_## ID];\ - bf r3, internal_channel_## ID ##_done;\ - out res[r3], r3;\ - out res[r3], r3;\ - ldap r11, internal_channel_## ID ##_event_vector;\ - setv res[r3], r11;\ - eeu res[r3];\ - internal_channel_## ID ##_done: - - -.globl mic_array_decimate_to_pcm_4ch -.align 8 -.type mic_array_decimate_to_pcm_4ch,@function -.cc_top mic_array_decimate_to_pcm_4ch.function -mic_array_decimate_to_pcm_4ch: -.cfi_startproc -.issue_mode dual - DUALENTSP_lu6 STACKWORDS - - ldaw r3, sp[S_STORAGE] - stw r0, r3[S_C_INPUT] - stw r1, r3[S_C_OUTPUT] - - clre - //if r2 != 0 then store the internal channels to the stack - bf r2, no_internal_channels_in_use - SETUP_INTERNAL_CHANNEL(0) - SETUP_INTERNAL_CHANNEL(1) - SETUP_INTERNAL_CHANNEL(2) - SETUP_INTERNAL_CHANNEL(3) - bu internal_channel_setup_complete - - no_internal_channels_in_use: - stw r2, sp[S_FAR_END_CHANNEL_0] - stw r2, sp[S_FAR_END_CHANNEL_1] - stw r2, sp[S_FAR_END_CHANNEL_2] - stw r2, sp[S_FAR_END_CHANNEL_3] - - internal_channel_setup_complete: - - //Set the dp to point to the data area for the second stage FIR - ldaw dp, sp[S_SECOND_STAGE_DATA] - - outct res[r1], 8 //we say we are ready - inct r2, res[r1] //they say CONFIGURE_DECIMATOR - - // Initialise the DC offset removal. - ldaw r0, sp[S_DC_ELIMINATE]; - ldc r1, 0 - std r1, r1, r0[S_D_PREV_X_01] - std r1, r1, r0[S_D_PREV_X_23] - std r1, r1, r0[S_D_PREV_Y_0] - std r1, r1, r0[S_D_PREV_Y_1] - std r1, r1, r0[S_D_PREV_Y_2] - std r1, r1, r0[S_D_PREV_Y_3] - ldw r1, sp[S_DC_OFFSET_SAMPLE_NO] - ldc r1, 8 // This cotrols the rate of convergence of the DC offset - // for the initial sample. It has little effect, i.e. don't change it. - ldw r1, sp[S_DC_OFFSET_LOG2_CH0] - ldw r1, sp[S_DC_OFFSET_LOG2_CH1] - ldw r1, sp[S_DC_OFFSET_LOG2_CH2] - ldw r1, sp[S_DC_OFFSET_LOG2_CH3] - -configure: - DUALENTSP_lu6 0 - //Initialise the stack -- TODO optimise this - ldc r0, (S_DC_ELIMINATE - S_SECOND_STAGE_DATA)/2 - {ldaw r1, sp[S_SECOND_STAGE_DATA];ldc r2, 0} -stack_init_loop: - std r2, r2, r1[r0] - {bt r0, stack_init_loop; sub r0, r0, 1} - - ldc r3, 0 - ldaw r4, sp[S_FRAME_OFFSET] - stw r3, r4[S_FRAME_NUMBER] //and save the new frame number back - -initialise_frame_gain: - {ldc r11, 32; ldc r10, (32 - MIC_ARRAY_FIXED_GAIN)} - sub r10, r11, r10 - stw r10, r4[S_FRAME_GAIN] - -take_config_from_application: - //get the pointer for the config over the output channel - ldw r0, sp[S_C_OUTPUT] - in r2, res[r0] //deciamtor_config - ldw r3, r2[0]; //r3 is the pointer to the decimator_config_common - -//copy the setting out of the struct - ldaw r0, sp[S_FRAME_OFFSET] - ldw r11, r3[0] //frame_size_log2 - here_is_frame_size_log2: - shr r10, r11, 4 - bt r10, actualLength - stw r11, r0[S_FRAME_SIZE_LOG2] - mkmsk r11, r11 - add r11, r11, 1 - stw r11, r0[S_FRAME_SIZE] - bu lengthDone -actualLength: - {stw r11, r0[S_FRAME_SIZE] ;ldc r10, 33} - clz r11, r11 - sub r11, r10, r11 - stw r11, r0[S_FRAME_SIZE_LOG2] -lengthDone: - - - ldaw r0, sp[S_SETTINGS_OFFSET] - - ldw r11, r3[1] //apply_dc_offset - stw r11, r0[S_DC_OFFSET_REMOVAL_ENABLED] - - ldw r11, r3[2] //index_bit_reversal - stw r11, r0[S_INDEX_BITREVERSING_ENABLED] - - ldw r11, r3[3] //windowing_function - stw r11, r0[S_WINDOWING_ENABLED] - - ldw r11, r3[6] //apply mic gain compensation - stw r11, r0[S_MIC_GAIN_COMP] - - ldw r11, r3[7] //fir_gain_comp - stw r11, sp[S_FIR_GAIN_COMP] - - ldw r11, r3[4] //decimation factor - ldaw r10, sp[S_THIRD_STAGE] - stw r11, r10[S_THIRD_STAGE_PHASE_COUNT] - - here_is_the_coef_pointer: - {ldw r11, r3[5];} //coef pointer - ldc r9, (THIRD_STAGE_COEFS_PER_STAGE-1) //move the coef pointer along by (THIRD_STAGE_COEFS_PER_STAGE-1) - ldaw r11, r11[r9] - stw r11, r10[S_THIRD_STAGE_COEFS_POINER] - - here_is_the_data_pointer: - {ldw r11, r2[1];} //data pointer - stw r11, r10[S_THIRD_STAGE_DATA_POINTER] - - {ldw r11, r2[6];} //channel count - stw r11, sp[S_CHAN_COUNT] - - {ldw r11, r2[7];} // async interface enabled - stw r11, sp[S_ASYNC_INTERFACE] - -load_mic_gain_calib: - ldaw r1, sp[S_MIC_CALIB_OFFSET] - ldw r0, r2[2] - stw r0, r1[S_MIC_CALIB_0] - ldw r0, r2[3] - stw r0, r1[S_MIC_CALIB_1] - ldw r0, r2[4] - stw r0, r1[S_MIC_CALIB_2] - ldw r0, r2[5] - stw r0, r1[S_MIC_CALIB_3] - -init_frame_index: - ldaw r11, sp[S_FRAME_OFFSET] - ldc r1, 0 - stw r1, r11[S_FRAME_0_INDEX] - - ldw r1, r11[S_FRAME_SIZE] - shr r1, r1, 1 - stw r1, r11[S_FRAME_1_INDEX] - -get_frame_pointer: - ldw r2, sp[S_C_OUTPUT] - rx_buffer_count: - in r5, res[r2] - sub r5, r5, 1 - - bt r5, overlapping - non_overlapping: - {in r1, res[r2];stw r5, r11[S_OVERLAPPING_FRAMES]} // frames pointer - {in r1, res[r2];stw r1, r11[S_FRAME_POINTER_0]} // metadata pointer - saving_non_overlapping_metadata_pointer: - {stw r1, r11[S_METADATA_POINTER_0];ldc r2, 0 } - std r2, r2, r1[0] //init the sig bits - std r2, r2, r1[1] //init the sig bits - bu setup_phase_counters - - overlapping: - {in r1, res[r2];} - {in r1, res[r2];stw r1, r11[S_FRAME_POINTER_1]} - saving_overlapping_metadata_pointer_1: - {stw r1, r11[S_METADATA_POINTER_0]; ldc r3, 0} - std r3, r3, r1[0] //init the sig bits - std r3, r3, r1[1] //init the sig bits - - {in r1, res[r2];stw r5, r11[S_OVERLAPPING_FRAMES]} - {in r1, res[r2];stw r1, r11[S_FRAME_POINTER_0]} - saving_overlapping_metadata_pointer_0: - {stw r1, r11[S_METADATA_POINTER_1];ldc r2, 0 } - std r2, r2, r1[0] //init the sig bits - std r2, r2, r1[1] //init the sig bits - -setup_phase_counters: - ldaw r10, sp[S_THIRD_STAGE] - ldw r9, r10[S_THIRD_STAGE_PHASE_COUNT] - sub r9, r9, 1 - stw r9, r10[S_THIRD_STAGE_PHASE] - - ldc r9, (THIRD_STAGE_COEFS_PER_STAGE-1) - stw r9, r10[S_THIRD_STAGE_COEFS_PHASE] - -confirm_init_complete: - ldw r4, sp[S_C_OUTPUT] - outct res[r4], 8 //WARNING: do not change this - -input_0_0: - INPUT_TO_OFFSET_12_15(15) - divide_by_n_0_0: - DIVIDE_BY_N_0() - -input_1_0: - INPUT_TO_OFFSET_12_15(14) - divide_by_n_0_1: - N_DIVIDE_BY_N_1() - -input_2_0: - INPUT_TO_OFFSET_12_15(13) - bl post_process - -input_3_0: - INPUT_TO_OFFSET_12_15(12) - ldaw r7, dp[12] - bl divide_by_four - -input_4_0: - INPUT_TO_OFFSET(11) - divide_by_n_1_0: - DIVIDE_BY_N_0(); - -input_5_0: - INPUT_TO_OFFSET(10) - divide_by_n_1_1: - N_DIVIDE_BY_N_1() - -input_6_0: - INPUT_TO_OFFSET(9) - bl post_process - -input_7_0: - INPUT_TO_OFFSET(8) - ldaw r7, dp[8] - bl divide_by_four - -input_0_1: - INPUT_TO_OFFSET(7) - divide_by_n_2_0: - DIVIDE_BY_N_0(); - -input_1_1: - INPUT_TO_OFFSET(6) - divide_by_n_2_1: - N_DIVIDE_BY_N_1() - -input_2_1: - INPUT_TO_OFFSET(5) - bl post_process - -input_3_1: - INPUT_TO_OFFSET(4) - ldaw r7, dp[4] - bl divide_by_four - -input_4_1: - INPUT_TO_OFFSET(3) - divide_by_n_3_0: - DIVIDE_BY_N_0(); - -input_5_1: - INPUT_TO_OFFSET(2) - divide_by_n_3_1: - N_DIVIDE_BY_N_1() - -input_6_1: - INPUT_TO_OFFSET(1) - bl post_process - -input_7_1: - INPUT_TO_OFFSET(0) - ldaw r7, dp[0] - bl divide_by_four - bu input_0_0 - - .cc_bottom mic_array_decimate_to_pcm_4ch.function - .set mic_array_decimate_to_pcm_4ch.nstackwords, STACKWORDS - .globl mic_array_decimate_to_pcm_4ch.nstackwords - .set mic_array_decimate_to_pcm_4ch.maxcores,1 - .globl mic_array_decimate_to_pcm_4ch.maxcores - .set mic_array_decimate_to_pcm_4ch.maxtimers,0 - .globl mic_array_decimate_to_pcm_4ch.maxtimers - .set mic_array_decimate_to_pcm_4ch.maxchanends,0 - .globl mic_array_decimate_to_pcm_4ch.maxchanends -.Lmic_array_decimate_to_pcm_4ch_tmp: - .size mic_array_decimate_to_pcm_4ch, .Lmic_array_decimate_to_pcm_4ch_tmp-mic_array_decimate_to_pcm_4ch - .cfi_endproc - -////////////////////////////////////////////////////////////////////////////////////////// - -.globl post_process -.align 8 -.type post_process,@function -.cc_top post_process.function -post_process: - .cfi_startproc - .issue_mode dual - - //increment THIRD_STAGE_PHASE mod THIRD_STAGE_PHASE_COUNT - ldaw r11, sp[S_THIRD_STAGE] - ldw r10, r11[S_THIRD_STAGE_PHASE]; - {add r9, r10, 1; ldw r8, r11[S_THIRD_STAGE_PHASE_COUNT]} - {stw r9, r11[S_THIRD_STAGE_PHASE];eq r8, r8, r9} - - bt r8, output_phase //do this on phase S_THIRD_STAGE_PHASE_COUNT-1 (last phase) - {sub r10, r10, 1; bf r10, process_phase} //do this on phase 0 - {sub r10, r10, 1; bf r10, analytics0} //do this on phase 1 - retsp 0 - - analytics0: - - ldaw r4, sp[S_OUTPUT_STORAGE]; - ldd r0, r1, r4[S_D_OUTPUT_STORAGE_01]; - ldd r2, r3, r4[S_D_OUTPUT_STORAGE_23]; - - {ldc r4, 0; ldc r5, 0} - maccs r4, r5, r0, r0 - - - ldaw r10, sp[S_FRAME_OFFSET] - - ldd r9, r8, r10[S_D_METADATA_POINTERS] - ldw r10, r10[S_OVERLAPPING_FRAMES] - - //copy r8 over r9 to stop - //exceptions in non-overlapping frames - {bt r10, update_sig_bits; ldc r11, 0} - mov r9, r8 - update_sig_bits: - - {lss r4, r0, r11;lss r5, r1, r11} - {bf r4, r0_done; mov r4, r0} - neg r4, r0 - r0_done: - {bf r5, r1_done; mov r5, r1} - neg r5, r1 - r1_done: - - ldd r7, r6, r8[0] - {or r6, r6, r4; or r7, r7, r5} - std r7, r6, r8[0] - - ldd r7, r6, r9[0] - {or r6, r6, r4; or r7, r7, r5} - std r7, r6, r9[0] - - {lss r4, r2, r11;lss r5, r3, r11} - {bf r4, r2_done; mov r4, r2} - neg r4, r2 - r2_done: - {bf r5, r3_done; mov r5, r3} - neg r5, r3 - r3_done: - - ldd r7, r6, r8[1] - {or r6, r6, r4; or r7, r7, r5} - std r7, r6, r8[1] - - ldd r7, r6, r9[1] - {or r6, r6, r4; or r7, r7, r5} - std r7, r6, r9[1] - retsp 0 - - - process_phase: - //r0, r1, r2, r3 are used as storage for the output of the 3rd stage FIR - //copy the accumulators in to registers - ldaw r4, sp[S_OUTPUT_STORAGE]; - ldd r0, r1, r4[S_D_OUTPUT_STORAGE_01]; - ldd r2, r3, r4[S_D_OUTPUT_STORAGE_23]; - - //DC offset removal - ldaw r4, sp[S_SETTINGS_OFFSET] - ldw r4, r4[S_DC_OFFSET_REMOVAL_ENABLED] - bf r4, dc_offset_removal_complete - - ldaw r4, sp[S_DC_ELIMINATE] - dc_offset_removal_ch0: - DC_OFFSET_REMOVAL(S_D_PREV_Y_0, S_PREV_X_0, r0); - dc_offset_removal_ch1: - DC_OFFSET_REMOVAL(S_D_PREV_Y_1, S_PREV_X_1, r1); - dc_offset_removal_ch2: - DC_OFFSET_REMOVAL(S_D_PREV_Y_2, S_PREV_X_2, r2); - dc_offset_removal_ch3: - DC_OFFSET_REMOVAL(S_D_PREV_Y_3, S_PREV_X_3, r3); - -dc_offset_removal_complete: - -#define COMP(REG)\ - {ldc r5, 0; ldc r6, 0};\ - maccs r5, r6, REG, r4;\ - lsats r5, r6, r7;\ - lextract REG, r5, r6, r7, 32 - - //FIR gain compensation - fir_compensation: // This normally turns the volume up to compensate for the FIR - ldw r4, sp[S_FIR_GAIN_COMP] //load the fir gain comp, it is in 1.4.27 format - {bf r4, gain_compensation;ldc r7, 27} - COMP(r0) - COMP(r1) - COMP(r2) - COMP(r3) - - gain_compensation: // This always turns the volume down - ldaw r4, sp[S_SETTINGS_OFFSET] - ldw r4, r4[S_MIC_GAIN_COMP] - {bf r4, gain_comp_complete;ldc r7, 31} - apply_mic_gain_compensation: - ldaw r4, sp[S_MIC_CALIB_OFFSET] - ldd r6, r5, r4[S_D_MIC_CALIB_01] - {ldc r8, 0; ldc r9, 0} - maccs r8, r9, r0, r5 - lextract r0, r8, r9, r7, 32 - {ldc r8, 0; ldc r9, 0} - maccs r8, r9, r1, r6 - lextract r1, r8, r9, r7, 32 - ldd r6, r5, r4[S_D_MIC_CALIB_23] - {ldc r8, 0; ldc r9, 0} - maccs r8, r9, r2, r5 - lextract r2, r8, r9, r7, 32 - {ldc r8, 0; ldc r9, 0} - maccs r8, r9, r3, r6 - lextract r3, r8, r9, r7, 32 - gain_comp_complete: - - -internal_channel_overwrite_begin: - setsr 0x1 - nop - {bu internal_channel_overwrite_complete; clrsr 0x1} - internal_channel_0_event_vector: - get r11, ed - in r0, res[r11] //input from the channel (to overwrite channel 3) - {out res[r11], r0; bu internal_channel_overwrite_begin} //output another token to the channel to let it know we have more space - internal_channel_1_event_vector: - get r11, ed - in r1, res[r11] //input from the channel (to overwrite channel 3) - {out res[r11], r1; bu internal_channel_overwrite_begin} //output another token to the channel to let it know we have more space - internal_channel_2_event_vector: - get r11, ed - in r2, res[r11] //input from the channel (to overwrite channel 3) - {out res[r11], r2; bu internal_channel_overwrite_begin} //output another token to the channel to let it know we have more space - internal_channel_3_event_vector: - get r11, ed - in r3, res[r11] //input from the channel (to overwrite channel 3) - {out res[r11], r3; bu internal_channel_overwrite_begin} //output another token to the channel to let it know we have more space - internal_channel_overwrite_complete: - - ldaw r4, sp[S_OUTPUT_STORAGE]; - std r0, r1, r4[S_D_OUTPUT_STORAGE_01]; - std r2, r3, r4[S_D_OUTPUT_STORAGE_23]; - retsp 0 - - output_phase: - -#define EXCHANGE_BUFFERS 0 -#define CONFIGURE_DECIMATOR 1 - - ldaw r4, sp[S_OUTPUT_STORAGE]; - ldd r0, r1, r4[S_D_OUTPUT_STORAGE_01]; - ldd r2, r3, r4[S_D_OUTPUT_STORAGE_23]; - - ldaw r4, sp[S_FRAME_OFFSET] - - ldw r6, r4[S_FRAME_0_INDEX] - - APPLY_WINDOW_FN(0) - ldaw r4, sp[S_FRAME_OFFSET] - - ldaw r5, sp[S_SETTINGS_OFFSET] - ldw r5, r5[S_INDEX_BITREVERSING_ENABLED] - { bt r5, index_bitrev_order_0 ; eq r5, r5, 2 } - index_normal_order_0: - SAVE_SAMPLES_NORMAL(S_FRAME_POINTER_0, 0); - bu save_to_frame_complete_0 - index_bitrev_order_0: - bt r5, index_packed_0 - SAVE_SAMPLES_BIT_REVERSED(S_FRAME_POINTER_0); - bu save_to_frame_complete_0 - index_packed_0: - SAVE_SAMPLES_PACKED(S_FRAME_POINTER_0); - save_to_frame_complete_0: - - ldw r5, r4[S_FRAME_0_INDEX] - {add r5, r5, 1;ldw r6, r4[S_OVERLAPPING_FRAMES]} - stw r5, r4[S_FRAME_0_INDEX] - - ldw r11, sp[S_ASYNC_INTERFACE] - bt r11, async_send_samples - - bt r6, overlapping_frames - no_overlapping_frames: - - ldw r6, r4[S_FRAME_SIZE] - {eq r5, r5, r6; ldc r6, 0} - bf r5, do_the_rest; - - reset_the_frame_index: - stw r6, r4[S_FRAME_0_INDEX] - - write_the_current_frames_metadata: - - ldw r5, r4[S_METADATA_POINTER_0] - ldw r3, r4[S_FRAME_NUMBER] - {stw r3, r5[4]; add r3, r3, 1} //if metadata layout changes then this needs to change too - stw r3, r4[S_FRAME_NUMBER] //and save the new frame number back - - exchange_buffers: - ldw r6, sp[S_C_OUTPUT] - outct res[r6], 8 //WARNING: do not change this - inct r3, res[r6] - - eq r5, r3, EXCHANGE_BUFFERS //if the incomming token is EXCHANGE_BUFFERS then do that - {bt r5, do_the_exchange; eq r5, r3, CONFIGURE_DECIMATOR} //if the incomming token is CONFIGURE_DECIMATOR then do that - - ldap r11, configure - stw r11, sp[0] - ldw lr, sp[0] - retsp 0 - - do_the_exchange: - {in r3, res[r6]; ldc r0, 0} - {std r0, r3, r4[S_D_FRAME_POINTER_AND_INDEX_0]} - - get_the_new_metadata_pointer: - {in r3, res[r6]} - {stw r3, r4[S_METADATA_POINTER_0]} - std r0, r0, r3[0] //set the frame sig bits to 0 - std r0, r0, r3[1] //set the frame sig bits to 0 - - ldw r4, sp[S_C_OUTPUT] - outct res[r4], 8 //WARNING: do not change this - no_overlapping_frames_done: - bu do_the_rest - - overlapping_frames: - - ldaw r4, sp[S_FRAME_OFFSET] - ldw r6, r4[S_FRAME_1_INDEX] //load second frame index - - ldaw r5, sp[S_OUTPUT_STORAGE]; - ldd r0, r1, r5[S_D_OUTPUT_STORAGE_01]; - ldd r2, r3, r5[S_D_OUTPUT_STORAGE_23]; - - APPLY_WINDOW_FN(1) - ldaw r4, sp[S_FRAME_OFFSET] - ldw r6, r4[S_FRAME_1_INDEX] //load second frame index - - ldaw r5, sp[S_SETTINGS_OFFSET] - ldw r5, r5[S_INDEX_BITREVERSING_ENABLED] - { bt r5, index_bitrev_order_1 ; eq r5, r5, 2 } - index_normal_order_1: - SAVE_SAMPLES_NORMAL(S_FRAME_POINTER_1, 1); - bu save_to_frame_complete_1 - index_bitrev_order_1: - bt r5, index_packed_1 - SAVE_SAMPLES_BIT_REVERSED(S_FRAME_POINTER_1); - bu save_to_frame_complete_1 - index_packed_1: - SAVE_SAMPLES_PACKED(S_FRAME_POINTER_1); - save_to_frame_complete_1: - - ldw r5, r4[S_FRAME_1_INDEX] - {add r5, r5, 1;ldw r6, r4[S_FRAME_SIZE]} - stw r5, r4[S_FRAME_1_INDEX] - - - {eq r5, r5, r6; ldc r6, 0} - bf r5, do_the_rest; - at_the_end_of_the_overlapping_half_frame: - - //set the metadata - ldw r5, r4[S_METADATA_POINTER_0] - ldw r3, r4[S_FRAME_NUMBER] - {stw r3, r5[4]; add r3, r3, 1} //if metadata layout changes then this needs to change too - stw r3, r4[S_FRAME_NUMBER] //and save the new frame number back - - ldw r6, sp[S_C_OUTPUT] - outct res[r6], 8 //WARNING: do not change this - - stw r3, r4[S_FRAME_NUMBER] //and save the new frame number back - inct r11, res[r6] - - eq r5, r11, EXCHANGE_BUFFERS //if the incomming token is EXCHANGE_BUFFERS then do that - {bt r5, flip_the_frames; eq r5, r11, CONFIGURE_DECIMATOR} //if the incomming token is CONFIGURE_DECIMATOR then do that - - ldap r11, configure - stw r11, sp[0] - ldw lr, sp[0] - retsp 0 - -.align 8 - flip_the_frames: - ldd r3, r5, r4[S_D_FRAME_POINTER_AND_INDEX_0] - std r3, r5, r4[S_D_FRAME_POINTER_AND_INDEX_1] - - ldw r5, r4[S_METADATA_POINTER_1] - {in r3, res[r6]; ldc r0, 0} - stw r5, r4[S_METADATA_POINTER_0] - - {std r0, r3, r4[S_D_FRAME_POINTER_AND_INDEX_0]} - - get_the_new_metadata_pointer2: - {in r5, res[r6];ldw r7, sp[S_C_OUTPUT]} - {outct res[r7], 8; stw r5, r4[S_METADATA_POINTER_1]}//WARNING: do not change this - std r0, r0, r5[0] //reset the frame sig bits to 0 - std r0, r0, r5[1] //reset the frame sig bits to 0 - - async_send_samples: - ldc r6, 0 - stw r6, r4[S_FRAME_0_INDEX] - - ldw r9, sp[S_C_OUTPUT] - {ldc r5, 1<<(MIC_ARRAY_MAX_FRAME_SIZE_LOG2)} - {add r7, r6, r5; ldw r8, r4[S_FRAME_POINTER_0]} - - ldw r10, r8[r6] // Load mic 1 sample - ldw r11, r8[r7] // Load mic 0 sample - - out res[r9], r10 - out res[r9], r11 - - bu do_the_rest - - do_the_rest: - ldaw r11, sp[S_THIRD_STAGE] - ldaw r4, sp[S_FRAME_OFFSET] - - - - //copy accumulators to store - {ldw r10, r4[S_FRAME_GAIN]; ldc r7, 0} - {lss r5, r10, r7; ldc r7, 32} - {bt r5, apply_negative_frame_gain; sub r7, r7, r10} - -apply_positive_frame_gain: - ldd r5, r6, r11[S_D_THIRD_STAGE_CH0_ACC] - lextract r0, r5, r6, r7, 32 - ldd r5, r6, r11[S_D_THIRD_STAGE_CH1_ACC] - lextract r1, r5, r6, r7, 32 - ldd r5, r6, r11[S_D_THIRD_STAGE_CH2_ACC] - lextract r2, r5, r6, r7, 32 - ldd r5, r6, r11[S_D_THIRD_STAGE_CH3_ACC] - lextract r3, r5, r6, r7, 32 - {bu frame_gain_complete; ldc r10, 0} - -apply_negative_frame_gain: - {neg r7, r10; ldc r10, 0} - ldd r5, r6, r11[S_D_THIRD_STAGE_CH0_ACC] - ashr r0, r5, r7 - ldd r5, r6, r11[S_D_THIRD_STAGE_CH1_ACC] - ashr r1, r5, r7 - ldd r5, r6, r11[S_D_THIRD_STAGE_CH2_ACC] - ashr r2, r5, r7 - ldd r5, r6, r11[S_D_THIRD_STAGE_CH3_ACC] - ashr r3, r5, r7 - -frame_gain_complete: - ldaw r4, sp[S_OUTPUT_STORAGE]; - std r0, r1, r4[S_D_OUTPUT_STORAGE_01]; - std r2, r3, r4[S_D_OUTPUT_STORAGE_23]; - - //increment S_THIRD_STAGE_COEFS_PHASE mod THIRD_STAGE_COEFS_PER_STAGE - {ldw r1, r11[S_THIRD_STAGE_COEFS_PHASE]; ldc r9, THIRD_STAGE_COEFS_PER_STAGE} - //set S_THIRD_STAGE_PHASE to 0 - {add r1, r1, 1} - {stw r10, r11[S_THIRD_STAGE_PHASE];lsu r9, r1, r9} - //reset accumulators - - std r10, r10, r11[S_D_THIRD_STAGE_CH0_ACC] - std r10, r10, r11[S_D_THIRD_STAGE_CH1_ACC] - mul r1, r1, r9 - std r10, r10, r11[S_D_THIRD_STAGE_CH2_ACC] - std r10, r10, r11[S_D_THIRD_STAGE_CH3_ACC] - - stw r1, r11[S_THIRD_STAGE_COEFS_PHASE] - retsp 0 - -.cc_bottom post_process.function - .set post_process.nstackwords, 0 - .globl post_process.nstackwords - .set post_process.maxcores,1 - .globl post_process.maxcores - .set post_process.maxtimers,0 - .globl post_process.maxtimers - .set post_process.maxchanends,0 - .globl post_process.maxchanends -.Lpost_process_tmp: - .size post_process, .Lpost_process_tmp-post_process - .cfi_endproc - -/////////////////////////////////////////////////////////////////////////////////////////// - -.globl divide_by_four -.align 8 -.type divide_by_four,@function -.cc_top divide_by_four.function -divide_by_four: - .cfi_startproc - .issue_mode dual - - ldaw r10, sp[S_THIRD_STAGE] - {ldw r8, sp[S_CHAN_COUNT];ldc r11, THIRD_STAGE_COEFS_PER_STAGE} //r11 = 32 - mul r8, r8, r11 - {ldw r11, r10[S_THIRD_STAGE_PHASE]; shl r6, r11, 2} - mul r8, r8, r11 - ldw r11, r10[S_THIRD_STAGE_COEFS_PHASE] - {ldw r10, r10[S_THIRD_STAGE_DATA_POINTER];add r8, r8, r11} - ldaw r10, r10[r8] - - ldw r8, sp[S_CHAN_COUNT] - {dualentsp 1; eq r9, r8, 4} - ldaw r11, cp[g_second_stage_fir] //------------------------------------------------------------------------------------------------------------ This needs fixing - - {bt r9, mic_array_decimate_to_pcm_4ch_0; eq r9, r8, 3} - {bt r9, mic_array_decimate_to_pcm_4ch_1; eq r9, r8, 2} - {bt r9, mic_array_decimate_to_pcm_4ch_2; eq r9, r8, 1} - {bt r9, mic_array_decimate_to_pcm_4ch_3;} - bu divide_by_four_complete - - //r11 = coefs, r10 = pointer to where to put result, r7 = data, r6 = THIRD_STAGE_COEFS_PER_STAGE*sizeof(int) -mic_array_decimate_to_pcm_4ch_0: - {bl mic_array_decimate_to_pcm_4ch_fir_impl ; }// data, coefs need to be set; h, l, c0, c1, d0, d1; return h(r0), l(r1); - {stw r0, r10[0]; add r10, r10, r6} -mic_array_decimate_to_pcm_4ch_1: - {bl mic_array_decimate_to_pcm_4ch_fir_impl ; add r7, r7, r6}// data, coefs need to be set; h, l, c0, c1, d0, d1; return h(r0), l(r1); - {stw r0, r10[0]; add r10, r10, r6} -mic_array_decimate_to_pcm_4ch_2: - {bl mic_array_decimate_to_pcm_4ch_fir_impl ; add r7, r7, r6}// data, coefs need to be set; h, l, c0, c1, d0, d1; return h(r0), l(r1); - {stw r0, r10[0]; add r10, r10, r6} -mic_array_decimate_to_pcm_4ch_3: - {bl mic_array_decimate_to_pcm_4ch_fir_impl ; add r7, r7, r6}// data, coefs need to be set; h, l, c0, c1, d0, d1; return h(r0), l(r1); - stw r0, r10[0] - -divide_by_four_complete: - retsp 1 - .cc_bottom divide_by_four.function - .set divide_by_four.nstackwords, 1 - .globl divide_by_four.nstackwords - .set divide_by_four.maxcores,1 - .globl divide_by_four.maxcores - .set divide_by_four.maxtimers,0 - .globl divide_by_four.maxtimers - .set divide_by_four.maxchanends,0 - .globl divide_by_four.maxchanends -.Ldivide_by_four_tmp: - .size divide_by_four, .Ldivide_by_four_tmp-divide_by_four - .cfi_endproc - -/////////////////////////////////////////////////////////////////////////////////////////// - -////This is the actual implementation of the third stage FIR - -.globl third_stage_fir_impl -.align 8 -.type third_stage_fir_impl,@function -.cc_top third_stage_fir_impl.function -third_stage_fir_impl: - .cfi_startproc - .issue_mode dual - -#define TWO_TAPS(I, COEFS, H0, L0, DATA0, H1, L1, DATA1)\ - {ldw r0, COEFS[0]; add COEFS, COEFS, 4};\ - ldd r2, r1, DATA0[I];\ - ldd r4, r3, DATA1[I];\ - maccs H0, L0, r1, r0;\ - maccs H1, L1, r3, r0;\ - {ldw r0, COEFS[0]; add COEFS, COEFS, 4};\ - maccs H0, L0, r2, r0;\ - maccs H1, L1, r4, r0 - - TWO_TAPS(0, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(1, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(2, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(3, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(4, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(5, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(6, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(7, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(8, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(9, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(10, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(11, r9, r8, r7, r10, r6, r5, r11) - ldc r0, 4*24 - {add r10, r10, r0; add r11, r11, r0} - TWO_TAPS(0, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(1, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(2, r9, r8, r7, r10, r6, r5, r11) - TWO_TAPS(3, r9, r8, r7, r10, r6, r5, r11) - retsp 0 - .cc_bottom third_stage_fir_impl.function - .set third_stage_fir_impl.nstackwords, 0 - .globl third_stage_fir_impl.nstackwords - .set third_stage_fir_impl.maxcores,1 - .globl third_stage_fir_impl.maxcores - .set third_stage_fir_impl.maxtimers,0 - .globl third_stage_fir_impl.maxtimers - .set third_stage_fir_impl.maxchanends,0 - .globl third_stage_fir_impl.maxchanends -.Lthird_stage_fir_impl_tmp: - .size third_stage_fir_impl, .Lthird_stage_fir_impl_tmp-third_stage_fir_impl - .cfi_endproc - -/////////////////////////////////////////////////////////////////////////////////////////// - -////This is the actual implementation of the second stage FIR - -.globl mic_array_decimate_to_pcm_4ch_fir_impl -.align 8 -.type mic_array_decimate_to_pcm_4ch_fir_impl,@function -.cc_top mic_array_decimate_to_pcm_4ch_fir_impl.function -mic_array_decimate_to_pcm_4ch_fir_impl: - .cfi_startproc - .issue_mode dual - - //r0, r1, r2, r3, r4, r5, r6 = 31, r7, r10, r11, - {ldc r0, 0; ldc r1, 0} //Initialise the accumulators - - ldd r3, r2, r11[0] - ldd r5, r4, r7[0] - maccs r0, r1, r4, r2 - maccs r0, r1, r5, r3 - ldd r5, r4, r7[7] - maccs r0, r1, r4, r3 - maccs r0, r1, r5, r2 - - ldd r3, r2, r11[1] - ldd r5, r4, r7[1] - maccs r0, r1, r4, r2 - maccs r0, r1, r5, r3 - ldd r5, r4, r7[6] - maccs r0, r1, r4, r3 - maccs r0, r1, r5, r2 - - ldd r3, r2, r11[2] - ldd r5, r4, r7[2] - maccs r0, r1, r4, r2 - maccs r0, r1, r5, r3 - ldd r5, r4, r7[5] - maccs r0, r1, r4, r3 - maccs r0, r1, r5, r2 - - ldd r3, r2, r11[3] - ldd r5, r4, r7[3] - maccs r0, r1, r4, r2 - maccs r0, r1, r5, r3 - ldd r5, r4, r7[4] - maccs r0, r1, r4, r3 - maccs r0, r1, r5, r2 - - retsp 0 - .cc_bottom mic_array_decimate_to_pcm_4ch_fir_impl.function - .set mic_array_decimate_to_pcm_4ch_fir_impl.nstackwords, 0 - .globl mic_array_decimate_to_pcm_4ch_fir_impl.nstackwords - .set mic_array_decimate_to_pcm_4ch_fir_impl.maxcores,1 - .globl mic_array_decimate_to_pcm_4ch_fir_impl.maxcores - .set mic_array_decimate_to_pcm_4ch_fir_impl.maxtimers,0 - .globl mic_array_decimate_to_pcm_4ch_fir_impl.maxtimers - .set mic_array_decimate_to_pcm_4ch_fir_impl.maxchanends,0 - .globl mic_array_decimate_to_pcm_4ch_fir_impl.maxchanends -.Lmic_array_decimate_to_pcm_4ch_fir_impl_tmp: - .size mic_array_decimate_to_pcm_4ch_fir_impl, .Lmic_array_decimate_to_pcm_4ch_fir_impl_tmp-mic_array_decimate_to_pcm_4ch_fir_impl - -.cfi_endproc - -//This is for testing the DC offset elimination -//void dc_eliminate_tester(int &x, long long &y) -.globl dc_eliminate_tester -.align 8 -.type dc_eliminate_tester,@function -.cc_top dc_eliminate_tester.function -dc_eliminate_tester: - .cfi_startproc - .issue_mode dual - dualentsp 16 - - std r4, r5, sp[2] - std r6, r7, sp[3] - std r8, r9, sp[4] - std r10, r11, sp[5] - - ldw r2, r0[0] - mov r4, r1 - DC_OFFSET_REMOVAL(S_D_PREV_Y_0, S_PREV_X_0, r2); //TODO setup the last arg - stw r2, r0[0] - - ldd r4, r5, sp[2] - ldd r6, r7, sp[3] - ldd r8, r9, sp[4] - ldd r10, r11, sp[5] - - retsp 16 - .cc_bottom dc_eliminate_tester.function - .set dc_eliminate_tester.nstackwords, 16 - .globl dc_eliminate_tester.nstackwords - .set dc_eliminate_tester.maxcores,1 - .globl dc_eliminate_tester.maxcores - .set dc_eliminate_tester.maxtimers,0 - .globl dc_eliminate_tester.maxtimers - .set dc_eliminate_tester.maxchanends,0 - .globl dc_eliminate_tester.maxchanends -.Ldc_eliminate_tester_tmp: - .size dc_eliminate_tester, .Ldc_eliminate_tester_tmp-dc_eliminate_tester - .cfi_endproc - - //endpoint section - -#define STRINGIZE(S) #S - -#define EP_MARCO(ID, PASS) \ - .ascii STRINGIZE( input_ ## ID ## _ ## PASS ## _ep ) ;\ - .byte 0 ;\ - .ascii "" ;\ - .byte 0 ;\ - .long 0 ;\ - .long .Laddr_end ## ID ## _ ## PASS ## -.Laddr_start ## ID ## _ ## PASS;\ - .Laddr_start ## ID ## _ ## PASS : ;\ - .cc_top cc_ ## ID ## _ ## PASS ## ,input_ ## ID ## _ ## PASS ;\ - .long input_ ## ID ## _ ## PASS ;\ - .byte 0 ;\ - .cc_bottom cc_ ## ID ## _ ## PASS ;\ - .Laddr_end ## ID ## _ ## PASS : - -#define EPT_MARCO(ID, PASS) \ -.cc_top cc_a ## ID ## _ ## PASS,input_ ## ID ## _ ## PASS ;\ - .ascii "";\ - .byte 0;\ - .long 0;\ - .long input_ ## ID ## _ ## PASS;\ -.cc_bottom cc_a ## ID ## _ ## PASS - - .section .xtaendpoint,"",@progbits -.Lentries_start0: - .long .Lentries_end0-.Lentries_start0 - .long 1 - .ascii "" - .byte 0 - EP_MARCO(0, 0) - EP_MARCO(1, 0) - EP_MARCO(2, 0) - EP_MARCO(3, 0) - EP_MARCO(4, 0) - EP_MARCO(5, 0) - EP_MARCO(6, 0) - EP_MARCO(7, 0) - EP_MARCO(0, 1) - EP_MARCO(1, 1) - EP_MARCO(2, 1) - EP_MARCO(3, 1) - EP_MARCO(4, 1) - EP_MARCO(5, 1) - EP_MARCO(6, 1) - EP_MARCO(7, 1) -.Laddr_end9: - -.Lentries_end0: - - .section .xtaendpointtable,"",@progbits -.Lentries_start1: - .long .Lentries_end1-.Lentries_start1 - .long 0 - .ascii "" - .byte 0 - EPT_MARCO(0, 0) - EPT_MARCO(1, 0) - EPT_MARCO(2, 0) - EPT_MARCO(3, 0) - EPT_MARCO(4, 0) - EPT_MARCO(5, 0) - EPT_MARCO(6, 0) - EPT_MARCO(7, 0) - EPT_MARCO(0, 1) - EPT_MARCO(1, 1) - EPT_MARCO(2, 1) - EPT_MARCO(3, 1) - EPT_MARCO(4, 1) - EPT_MARCO(5, 1) - EPT_MARCO(6, 1) - EPT_MARCO(7, 1) -.Lentries_end1: diff --git a/lib_mic_array/src/decimator_interface.xc b/lib_mic_array/src/decimator_interface.xc deleted file mode 100644 index a08d26e4..00000000 --- a/lib_mic_array/src/decimator_interface.xc +++ /dev/null @@ -1,262 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "mic_array.h" -#include -#include - -#define XASSERT_UNIT DEBUG_MIC_ARRAY - -#define DEBUG_UNIT MIC_ARRAY -#ifndef DEBUG_PRINT_ENABLE_MIC_ARRAY - #define DEBUG_PRINT_ENABLE_MIC_ARRAY 0 -#endif -#include "debug_print.h" - -#if DEBUG_MIC_ARRAY -#include "xassert.h" -#endif - -void mic_array_init_far_end_channels(mic_array_internal_audio_channels ch[4], - streaming chanend ?a, streaming chanend ?b, - streaming chanend ?c, streaming chanend ?d) { - unsafe { - ch[0] = isnull(a) ? 0 : (unsigned)a; - ch[1] = isnull(b) ? 0 : (unsigned)b; - ch[2] = isnull(c) ? 0 : (unsigned)c; - ch[3] = isnull(d) ? 0 : (unsigned)d; - } -} - -int mic_array_send_sample(streaming chanend c_to_decimator, int sample){ - select { - case c_to_decimator :> int:{ - c_to_decimator <: sample; - return 0; - } - default: - return 1; - } -} - -int mic_array_recv_samples(streaming chanend c_from_decimator, int &ch_a, int &ch_b) { - select { - case c_from_decimator :> ch_a: - c_from_decimator :> ch_b; - return 0; - default: - return 1; - } -} - -void mic_array_init_time_domain_frame( - streaming chanend c_from_decimator[], unsigned decimator_count, - unsigned &buffer, mic_array_frame_time_domain audio[], - mic_array_decimator_config_t dc[]){ - - unsigned frames=1; - mic_array_decimator_buffering_t buffering_type; - unsafe {buffering_type = dc[0].dcc->buffering_type;} - - if (buffering_type == DECIMATOR_NO_FRAME_OVERLAP){ - frames = 1; - } else if (buffering_type == DECIMATOR_HALF_FRAME_OVERLAP){ - frames = 2; - } else { - //fail -#if DEBUG_MIC_ARRAY - fail("Invalid buffering selected for: buffering_type"); -#else - __builtin_unreachable(); -#endif - } - - memset(audio, 0, sizeof(mic_array_frame_time_domain)*frames); - - for(unsigned i=0;ibuffering_type; - buffer_count = dc[0].dcc->number_of_frame_buffers; - } - if(buffering_type == DECIMATOR_NO_FRAME_OVERLAP) - index = buffer + buffer_count - 1; - else - index = buffer + buffer_count - 2; - - if(index >= buffer_count) - index-=buffer_count; - - buffer++; - if(buffer == buffer_count) - buffer = 0; - return &audio[index]; -} - -void mic_array_init_frequency_domain_frame(streaming chanend c_from_decimator[], unsigned decimator_count, - unsigned &buffer, mic_array_frame_fft_preprocessed f_fft_preprocessed[], mic_array_decimator_config_t dc[]){ - - unsigned frames; - mic_array_decimator_buffering_t buffering_type; - unsafe {buffering_type = dc[0].dcc->buffering_type;} - - if (buffering_type == DECIMATOR_NO_FRAME_OVERLAP){ - frames = 1; - } else if (buffering_type == DECIMATOR_HALF_FRAME_OVERLAP){ - frames = 2; - } else { - //fail -#if DEBUG_MIC_ARRAY - fail("Invalid buffering selected for: buffering_type"); -#else - __builtin_unreachable(); -#endif - } - - memset(f_fft_preprocessed, 0, sizeof(mic_array_frame_fft_preprocessed)*frames); - - for(unsigned i=0;ibuffering_type; - buffer_count = dc[0].dcc->number_of_frame_buffers; - } - if(buffering_type == DECIMATOR_NO_FRAME_OVERLAP) - index = buffer + buffer_count - 1; - else - index = buffer + buffer_count - 2; - - if(index >= buffer_count) - index-=buffer_count; - - buffer++; - if(buffer == buffer_count) - buffer = 0; - - return &f_fft_preprocessed[index]; -} - -void mic_array_decimator_configure( - streaming chanend c_from_decimator[], - unsigned decimator_count, - mic_array_decimator_config_t dc[]){ - - //TODO check the frame_size_log_2 is in bounds - for(unsigned i=0;i + +#include "mic_array/etc/filters_default.h" + + +// Each coefficient is 16 bits and the number of coefficients must be a multiple of 256. +// int32_t type so that it's word-aligned. So this is 512 16-bit coefficients. +const uint32_t stage1_coef[STAGE1_WORDS] = { + + 0x44160F8F, 0x728624D0, 0xC78D773F, 0xD11A533B, 0xB994B117, 0xF9DD63C6, 0x1648C29D, 0xE3E0D044, + 0x0685DE8B, 0x99B31247, 0xE76AE975, 0x9DCDBB9E, 0xF3BB6773, 0x5D2EADCF, 0xC4919B33, 0xA2F742C1, + 0x072C158D, 0xF1F90E3B, 0xFE621D09, 0xE85DAF9A, 0xB3EB742F, 0x21708CFF, 0xB8E13F1F, 0x635069C0, + 0xAD63E6DB, 0x5F1BCD30, 0xF3AE33AA, 0x93600FB8, 0x3BE00D92, 0xAB98EB9E, 0x1967B1F5, 0xB6CF8D6A, + 0x631FF8EC, 0x9F59D21F, 0xF8F1D3AB, 0xCBD3E860, 0x0C2F97A7, 0xAB971E3F, 0xF09735F2, 0x6E3FF18C, + 0x1F0000F1, 0xE0CDCBF5, 0xFDD98188, 0x206187EE, 0xEFC30C08, 0x2303377F, 0x5FA7660F, 0x1E0001F0, + 0x00FFFF01, 0x556E3958, 0x541693FA, 0x887F1328, 0x2991FC22, 0xBF92D054, 0x3538ED55, 0x01FFFE00, + 0x00000001, 0x998FF8CA, 0x33E59825, 0xD87F5E0A, 0xA0F5FC37, 0x48334F98, 0xA63FE333, 0x00000000, + 0x00000001, 0xE1F007C6, 0xA5539D61, 0xED2A6148, 0x250CA96F, 0x0D73954A, 0xC7C01F0F, 0x00000000, + 0x00000001, 0xFE00003E, 0x6CCF9E4B, 0xF1B380DC, 0x76039B1F, 0xA4F3E66C, 0xF80000FF, 0x00000000, + 0x00000001, 0xFFFFFFFE, 0x1C3F9F8D, 0x5496AA90, 0x12AAD255, 0x63F3F870, 0xFFFFFFFF, 0x00000000, + 0x00000001, 0xFFFFFFFE, 0x03FF9FF1, 0x9924CCE0, 0x0E664933, 0x1FF3FF80, 0xFFFFFFFF, 0x00000000, + 0x00000001, 0xFFFFFFFE, 0x00006001, 0xE1C70F00, 0x01E1C70F, 0x000C0000, 0xFFFFFFFF, 0x00000000, + 0x00000001, 0xFFFFFFFE, 0x00000001, 0xFE07F000, 0x001FC0FF, 0x00000000, 0xFFFFFFFF, 0x00000000, + 0x00000001, 0xFFFFFFFE, 0x00000001, 0xFFF80000, 0x00003FFF, 0x00000000, 0xFFFFFFFF, 0x00000000, + 0xFFFFFFFE, 0x00000001, 0xFFFFFFFE, 0x00000000, 0x00000000, 0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, + +}; \ No newline at end of file diff --git a/lib_mic_array/src/etc/stage2_fir_coef.c b/lib_mic_array/src/etc/stage2_fir_coef.c new file mode 100644 index 00000000..8f74b5bb --- /dev/null +++ b/lib_mic_array/src/etc/stage2_fir_coef.c @@ -0,0 +1,15 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "mic_array/etc/filters_default.h" + +const int32_t stage2_coef[STAGE2_TAP_COUNT] = +{-105236054, -62347810, 0, 65953291, 117774723, 144035351, 132321511, 79069112, 0, -85237729, + -153815787, -189160495, -174790492, -105826884, 0, 117554555, 215824649, 269024588, 252398572, + 156502398, 0, -184209095, -350502321, -453064042, -444181088, -292578413, 0, 408784125, 884781564, + 1366247631, 1777650249, 2051184703, 2147483647, 2051184703, 1777650249, 1366247631, 884781564, + 408784125, 0, -292578413, -444181088, -453064042, -350502321, -184209095, 0, 156502398, 252398572, + 269024588, 215824649, 117554555, 0, -105826884, -174790492, -189160495, -153815787, -85237729, 0, + 79069112, 132321511, 144035351, 117774723, 65953291, 0, -62347810, -105236054}; + +const right_shift_t stage2_shr = 4; \ No newline at end of file diff --git a/lib_mic_array/src/fir/fir_coefs.h b/lib_mic_array/src/fir/fir_coefs.h deleted file mode 100644 index 96325fed..00000000 --- a/lib_mic_array/src/fir/fir_coefs.h +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -extern const int g_first_stage_fir_0[256]; -extern const int g_first_stage_fir_1[256]; -extern const int g_first_stage_fir_2[256]; -extern const int fir1_debug[48]; -#define FIRST_STAGE_MAX_PASSBAND_OUTPUT (2022233792) - -extern const int g_second_stage_fir[8]; -extern const int fir2_debug[16]; - -extern const int g_third_stage_div_2_fir[126]; -extern const int fir3_div_2_debug[64]; -#define FIR_COMPENSATOR_DIV_2 (276212818) - -extern const int g_third_stage_div_4_fir[252]; -extern const int fir3_div_4_debug[128]; -#define FIR_COMPENSATOR_DIV_4 (285017600) - -extern const int g_third_stage_div_6_fir[378]; -extern const int fir3_div_6_debug[192]; -#define FIR_COMPENSATOR_DIV_6 (284180149) - -extern const int g_third_stage_div_8_fir[504]; -extern const int fir3_div_8_debug[256]; -#define FIR_COMPENSATOR_DIV_8 (285084376) - -extern const int g_third_stage_div_12_fir[756]; -extern const int fir3_div_12_debug[384]; -#define FIR_COMPENSATOR_DIV_12 (285567922) - -#define THIRD_STAGE_COEFS_PER_STAGE (32) diff --git a/lib_mic_array/src/fir/fir_coefs.xc b/lib_mic_array/src/fir/fir_coefs.xc deleted file mode 100644 index e6ce2077..00000000 --- a/lib_mic_array/src/fir/fir_coefs.xc +++ /dev/null @@ -1,568 +0,0 @@ -// Copyright 2016-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -const int g_first_stage_fir_0[256] = { - 0x007c8875, 0x0019620a, 0x00390209, 0xffd5db9f, 0x0052f4ad, 0xffefce43, 0x000f6e42, 0xffac47d7, - 0x00658a59, 0x000263ed, 0x002203ed, 0xffbedd83, 0x003bf691, 0xffd8d027, 0xfff87026, 0xff9549bb, - 0x00714dec, 0x000e2781, 0x002dc781, 0xffcaa116, 0x0047ba25, 0xffe493bb, 0x000433b9, 0xffa10d4f, - 0x005a4fd0, 0xfff72966, 0x0016c964, 0xffb3a2fa, 0x0030bc09, 0xffcd959e, 0xffed359e, 0xff8a0f33, - 0x0077d922, 0x0014b2b7, 0x003452b6, 0xffd12c4c, 0x004e455b, 0xffeb1ef0, 0x000abeef, 0xffa79885, - 0x0060db06, 0xfffdb49c, 0x001d549a, 0xffba2e30, 0x0037473e, 0xffd420d4, 0xfff3c0d3, 0xff909a68, - 0x006c9e9a, 0x0009782e, 0x0029182e, 0xffc5f1c4, 0x00430ad2, 0xffdfe468, 0xffff8467, 0xff9c5dfc, - 0x0055a07d, 0xfff27a13, 0x00121a11, 0xffaef3a7, 0x002c0cb6, 0xffc8e64c, 0xffe8864b, 0xff855fe0, - 0x007af931, 0x0017d2c6, 0x003772c5, 0xffd44c5b, 0x0051656a, 0xffee3f00, 0x000ddefe, 0xffaab894, - 0x0063fb15, 0x0000d4aa, 0x002074a9, 0xffbd4e3f, 0x003a674e, 0xffd740e3, 0xfff6e0e3, 0xff93ba78, - 0x006fbea9, 0x000c983e, 0x002c383d, 0xffc911d3, 0x00462ae1, 0xffe30477, 0x0002a475, 0xff9f7e0b, - 0x0058c08d, 0xfff59a22, 0x00153a21, 0xffb213b7, 0x002f2cc5, 0xffcc065b, 0xffeba65a, 0xff887fef, - 0x007649de, 0x00132373, 0x0032c373, 0xffcf9d08, 0x004cb617, 0xffe98fad, 0x00092fab, 0xffa60941, - 0x005f4bc2, 0xfffc2558, 0x001bc556, 0xffb89eec, 0x0035b7fb, 0xffd29191, 0xfff23190, 0xff8f0b25, - 0x006b0f56, 0x0007e8eb, 0x002788ea, 0xffc46280, 0x00417b8e, 0xffde5524, 0xfffdf524, 0xff9aceb8, - 0x0054113a, 0xfff0ead0, 0x00108ace, 0xffad6464, 0x002a7d72, 0xffc75708, 0xffe6f707, 0xff83d09c, - 0x007c2f64, 0x001908f9, 0x0038a8f8, 0xffd5828e, 0x00529b9c, 0xffef7532, 0x000f1530, 0xffabeec6, - 0x00653148, 0x00020adc, 0x0021aadc, 0xffbe8472, 0x003b9d80, 0xffd87716, 0xfff81715, 0xff94f0aa, - 0x0070f4db, 0x000dce70, 0x002d6e6f, 0xffca4805, 0x00476114, 0xffe43aaa, 0x0003daa8, 0xffa0b43e, - 0x0059f6bf, 0xfff6d055, 0x00167053, 0xffb349e9, 0x003062f8, 0xffcd3c8d, 0xffecdc8d, 0xff89b622, - 0x00778011, 0x001459a6, 0x0033f9a5, 0xffd0d33b, 0x004dec49, 0xffeac5df, 0x000a65de, 0xffa73f73, - 0x006081f5, 0xfffd5b8b, 0x001cfb89, 0xffb9d51f, 0x0036ee2d, 0xffd3c7c3, 0xfff367c2, 0xff904157, - 0x006c4588, 0x00091f1d, 0x0028bf1d, 0xffc598b2, 0x0042b1c1, 0xffdf8b57, 0xffff2b56, 0xff9c04eb, - 0x0055476c, 0xfff22102, 0x0011c100, 0xffae9a96, 0x002bb3a5, 0xffc88d3b, 0xffe82d3a, 0xff8506cf, - 0x007aa020, 0x001779b5, 0x003719b4, 0xffd3f34a, 0x00510c59, 0xffede5ef, 0x000d85ed, 0xffaa5f83, - 0x0063a204, 0x00007b99, 0x00201b98, 0xffbcf52e, 0x003a0e3c, 0xffd6e7d2, 0xfff687d2, 0xff936166, - 0x006f6598, 0x000c3f2d, 0x002bdf2c, 0xffc8b8c2, 0x0045d1d0, 0xffe2ab66, 0x00024b64, 0xff9f24fa, - 0x0058677b, 0xfff54111, 0x0014e110, 0xffb1baa5, 0x002ed3b4, 0xffcbad4a, 0xffeb4d49, 0xff8826de, - 0x0075f0cd, 0x0012ca62, 0x00326a62, 0xffcf43f7, 0x004c5d06, 0xffe9369c, 0x0008d69a, 0xffa5b030, - 0x005ef2b1, 0xfffbcc47, 0x001b6c45, 0xffb845db, 0x00355eea, 0xffd2387f, 0xfff1d87f, 0xff8eb214, - 0x006ab645, 0x00078fda, 0x00272fd9, 0xffc4096f, 0x0041227d, 0xffddfc13, 0xfffd9c13, 0xff9a75a7, - 0x0053b829, 0xfff091be, 0x001031bd, 0xffad0b53, 0x002a2461, 0xffc6fdf7, 0xffe69df6, 0xff83778b, - }; - -const int g_first_stage_fir_1[256] = { - 0xfdb8a922, 0x017a1df5, 0xffc79ff2, 0x038914c5, 0xfe8d645c, 0x024ed92f, 0x009c5b2b, 0x045dd000, - 0xfdc0e724, 0x01825bf8, 0xffcfddf5, 0x039152c8, 0xfe95a25f, 0x02571732, 0x00a4992e, 0x04660e02, - 0xfd4f0a49, 0x01107f1d, 0xff5e011a, 0x031f75ed, 0xfe23c584, 0x01e53a57, 0x0032bc53, 0x03f43127, - 0xfd57484c, 0x0118bd1f, 0xff663f1c, 0x0327b3f0, 0xfe2c0386, 0x01ed785a, 0x003afa56, 0x03fc6f2a, - 0xfd20ad6c, 0x00e22240, 0xff2fa43c, 0x02f11910, 0xfdf568a6, 0x01b6dd7a, 0x00045f76, 0x03c5d44a, - 0xfd28eb6f, 0x00ea6042, 0xff37e23f, 0x02f95712, 0xfdfda6a9, 0x01bf1b7c, 0x000c9d78, 0x03ce124d, - 0xfcb70e94, 0x00788367, 0xfec60564, 0x02877a37, 0xfd8bc9ce, 0x014d3ea1, 0xff9ac09e, 0x035c3572, - 0xfcbf4c96, 0x0080c16a, 0xfece4367, 0x028fb83a, 0xfd9407d1, 0x01557ca4, 0xffa2fea1, 0x03647374, - 0xfd1ec7c2, 0x00e03c96, 0xff2dbe92, 0x02ef3366, 0xfdf382fc, 0x01b4f7d0, 0x000279cc, 0x03c3eea0, - 0xfd2705c5, 0x00e87a98, 0xff35fc95, 0x02f77169, 0xfdfbc0ff, 0x01bd35d2, 0x000ab7ce, 0x03cc2ca3, - 0xfcb528ea, 0x00769dbd, 0xfec41fba, 0x0285948d, 0xfd89e424, 0x014b58f7, 0xff98daf4, 0x035a4fc8, - 0xfcbd66ec, 0x007edbc0, 0xfecc5dbd, 0x028dd290, 0xfd922227, 0x015396fa, 0xffa118f7, 0x03628dca, - 0xfc86cc0c, 0x004840e0, 0xfe95c2dd, 0x025737b0, 0xfd5b8747, 0x011cfc1a, 0xff6a7e17, 0x032bf2ea, - 0xfc8f0a0f, 0x00507ee3, 0xfe9e00df, 0x025f75b3, 0xfd63c549, 0x01253a1d, 0xff72bc1a, 0x033430ed, - 0xfc1d2d34, 0xffdea208, 0xfe2c2404, 0x01ed98d8, 0xfcf1e86e, 0x00b35d42, 0xff00df3f, 0x02c25412, - 0xfc256b37, 0xffe6e00b, 0xfe346207, 0x01f5d6da, 0xfcfa2671, 0x00bb9b44, 0xff091d41, 0x02ca9215, - 0xfd356deb, 0x00f6e2bf, 0xff4464bc, 0x0305d98f, 0xfe0a2926, 0x01cb9df9, 0x00191ff5, 0x03da94c9, - 0xfd3dabee, 0x00ff20c1, 0xff4ca2be, 0x030e1792, 0xfe126728, 0x01d3dbfc, 0x00215df8, 0x03e2d2cc, - 0xfccbcf13, 0x008d43e6, 0xfedac5e3, 0x029c3ab7, 0xfda08a4d, 0x0161ff21, 0xffaf811d, 0x0370f5f1, - 0xfcd40d16, 0x009581e9, 0xfee303e6, 0x02a478b9, 0xfda8c850, 0x016a3d23, 0xffb7bf20, 0x037933f4, - 0xfc9d7236, 0x005ee709, 0xfeac6906, 0x026dddd9, 0xfd722d70, 0x0133a243, 0xff812440, 0x03429914, - 0xfca5b038, 0x0067250c, 0xfeb4a709, 0x02761bdc, 0xfd7a6b73, 0x013be046, 0xff896243, 0x034ad716, - 0xfc33d35d, 0xfff54832, 0xfe42ca2e, 0x02043f01, 0xfd088e97, 0x00ca036b, 0xff178568, 0x02d8fa3b, - 0xfc3c1160, 0xfffd8634, 0xfe4b0830, 0x020c7d04, 0xfd10cc9a, 0x00d2416e, 0xff1fc36a, 0x02e1383e, - 0xfc9b8c8c, 0x005d015f, 0xfeaa835c, 0x026bf82f, 0xfd7047c6, 0x0131bc99, 0xff7f3e96, 0x0340b36a, - 0xfca3ca8e, 0x00653f62, 0xfeb2c15f, 0x02743632, 0xfd7885c9, 0x0139fa9c, 0xff877c99, 0x0348f16c, - 0xfc31edb3, 0xfff36288, 0xfe40e484, 0x02025957, 0xfd06a8ee, 0x00c81dc1, 0xff159fbe, 0x02d71491, - 0xfc3a2bb6, 0xfffba08a, 0xfe492286, 0x020a975a, 0xfd0ee6f0, 0x00d05bc4, 0xff1dddc0, 0x02df5294, - 0xfc0390d6, 0xffc505aa, 0xfe1287a6, 0x01d3fc7a, 0xfcd84c10, 0x0099c0e4, 0xfee742e1, 0x02a8b7b4, - 0xfc0bced9, 0xffcd43ad, 0xfe1ac5a9, 0x01dc3a7c, 0xfce08a13, 0x00a1fee6, 0xfeef80e3, 0x02b0f5b7, - 0xfb99f1fe, 0xff5b66d2, 0xfda8e8ce, 0x016a5da1, 0xfc6ead38, 0x0030220b, 0xfe7da408, 0x023f18dc, - 0xfba23000, 0xff63a4d5, 0xfdb126d1, 0x01729ba4, 0xfc76eb3b, 0x0038600e, 0xfe85e20b, 0x024756de, - }; - -const int g_first_stage_fir_2[256] = { - 0xc4e29679, 0xda921af4, 0xd9b07881, 0xef5ffcfc, 0xd8044cef, 0xedb3d169, 0xecd22ef7, 0x0281b371, - 0xd5b8509e, 0xeb67d519, 0xea8632a6, 0x0035b720, 0xe8da0713, 0xfe898b8e, 0xfda7e91c, 0x13576d96, - 0xd304902c, 0xe8b414a7, 0xe7d27234, 0xfd81f6af, 0xe62646a1, 0xfbd5cb1c, 0xfaf428aa, 0x10a3ad24, - 0xe3da4a51, 0xf989cecc, 0xf8a82c59, 0x0e57b0d3, 0xf6fc00c6, 0x0cab8540, 0x0bc9e2cd, 0x21796748, - 0xd0267dcb, 0xe5d60246, 0xe4f45fd3, 0xfaa3e44e, 0xe3483440, 0xf8f7b8bb, 0xf8161649, 0x0dc59ac3, - 0xe0fc37f0, 0xf6abbc6b, 0xf5ca19f8, 0x0b799e72, 0xf41dee65, 0x09cd72df, 0x08ebd06c, 0x1e9b54e7, - 0xde48777e, 0xf3f7fbf9, 0xf3165986, 0x08c5de00, 0xf16a2df3, 0x0719b26d, 0x06380ffb, 0x1be79476, - 0xef1e31a3, 0x04cdb61d, 0x03ec13aa, 0x199b9825, 0x023fe817, 0x17ef6c92, 0x170dca1f, 0x2cbd4e9a, - 0xcd58cd28, 0xe30851a3, 0xe226af30, 0xf7d633ab, 0xe07a839d, 0xf62a0818, 0xf54865a5, 0x0af7ea1f, - 0xde2e874d, 0xf3de0bc8, 0xf2fc6955, 0x08abedcf, 0xf1503dc2, 0x06ffc23c, 0x061e1fc9, 0x1bcda444, - 0xdb7ac6db, 0xf12a4b56, 0xf048a8e3, 0x05f82d5d, 0xee9c7d50, 0x044c01ca, 0x036a5f57, 0x1919e3d2, - 0xec508100, 0x0200057a, 0x011e6307, 0x16cde782, 0xff723775, 0x1521bbef, 0x1440197c, 0x29ef9df7, - 0xd89cb47a, 0xee4c38f5, 0xed6a9682, 0x031a1afc, 0xebbe6aef, 0x016def69, 0x008c4cf6, 0x163bd171, - 0xe9726e9f, 0xff21f31a, 0xfe4050a7, 0x13efd521, 0xfc942514, 0x1243a98e, 0x1162071b, 0x27118b96, - 0xe6beae2d, 0xfc6e32a8, 0xfb8c9035, 0x113c14af, 0xf9e064a2, 0x0f8fe91c, 0x0eae46a9, 0x245dcb24, - 0xf7946852, 0x0d43eccc, 0x0c624a59, 0x2211ced4, 0x0ab61ec6, 0x2065a341, 0x1f8400ce, 0x35338549, - 0xcacc7ab7, 0xe07bff32, 0xdf9a5cbf, 0xf549e13a, 0xddee312c, 0xf39db5a7, 0xf2bc1334, 0x086b97ae, - 0xdba234dc, 0xf151b957, 0xf07016e4, 0x061f9b5e, 0xeec3eb51, 0x04736fcb, 0x0391cd58, 0x194151d3, - 0xd8ee746a, 0xee9df8e5, 0xedbc5672, 0x036bdaec, 0xec102adf, 0x01bfaf59, 0x00de0ce6, 0x168d9161, - 0xe9c42e8f, 0xff73b30a, 0xfe921097, 0x14419511, 0xfce5e504, 0x1295697e, 0x11b3c70b, 0x27634b86, - 0xd6106209, 0xebbfe684, 0xeade4411, 0x008dc88b, 0xe932187e, 0xfee19cf9, 0xfdfffa86, 0x13af7f00, - 0xe6e61c2e, 0xfc95a0a9, 0xfbb3fe36, 0x116382b0, 0xfa07d2a3, 0x0fb7571d, 0x0ed5b4aa, 0x24853925, - 0xe4325bbc, 0xf9e1e037, 0xf9003dc4, 0x0eafc23e, 0xf7541231, 0x0d0396ab, 0x0c21f438, 0x21d178b3, - 0xf50815e1, 0x0ab79a5b, 0x09d5f7e8, 0x1f857c63, 0x0829cc55, 0x1dd950d0, 0x1cf7ae5d, 0x32a732d8, - 0xd342b166, 0xe8f235e1, 0xe810936e, 0xfdc017e9, 0xe66467db, 0xfc13ec56, 0xfb3249e3, 0x10e1ce5d, - 0xe4186b8a, 0xf9c7f005, 0xf8e64d93, 0x0e95d20d, 0xf73a2200, 0x0ce9a67a, 0x0c080407, 0x21b78882, - 0xe164ab19, 0xf7142f94, 0xf6328d21, 0x0be2119b, 0xf486618e, 0x0a35e608, 0x09544395, 0x1f03c810, - 0xf23a653d, 0x07e9e9b7, 0x07084745, 0x1cb7cbc0, 0x055c1bb2, 0x1b0ba02d, 0x1a29fdba, 0x2fd98235, - 0xde8698b8, 0xf4361d33, 0xf3547ac0, 0x0903ff3a, 0xf1a84f2d, 0x0757d3a7, 0x06763134, 0x1c25b5af, - 0xef5c52dc, 0x050bd756, 0x042a34e4, 0x19d9b95f, 0x027e0951, 0x182d8dcc, 0x174beb59, 0x2cfb6fd4, - 0xeca8926a, 0x025816e4, 0x01767472, 0x1725f8ed, 0xffca48e0, 0x1579cd5a, 0x14982ae7, 0x2a47af62, - 0xfd7e4c8f, 0x132dd109, 0x124c2e97, 0x27fbb311, 0x10a00304, 0x264f877f, 0x256de50c, 0x3b1d6987, - }; - -const int fir1_debug[48] = { - - -11400, -51105, -153513, -367940, -753422, -1362403, -2212661, -3248949, - -4300187, -5042351, -4980186, -3460972, 270081, 6970781, 17267560, 31505002, - 49607198, 70982487, 94499752, 118553817, 141221138, 160488250, 174518532, 181912125, - 181912125, 174518532, 160488250, 141221138, 118553817, 94499752, 70982487, 49607198, - 31505002, 17267560, 6970781, 270081, -3460972, -4980186, -5042351, -4300187, - -3248949, -2212661, -1362403, -753422, -367940, -153513, -51105, -11400, -}; -const int g_second_stage_fir[8] = { - 0xff597034, - 0xff0a5c2c, - 0x003003e0, - 0x04291e74, - 0x0d270ca5, - 0x197ff674, - 0x25a3ccb4, - 0x2dbfda3a, -}; - -const int fir2_debug[16] = { - -5457894, -8049130, 1573360, 34901818, 110331474, 213908282, 315745882, 383773981, - 383773981, 315745882, 213908282, 110331474, 34901818, 1573360, -8049130, -5457894, -}; - -const int g_third_stage_div_2_fir[126] = { -//Phase 1 - 0xfff7d2c9, 0x0007beed, 0x00040748, 0xffe2b924, 0x0049747f, 0xff7b9f11, 0x00c1e2cf, 0xff146ff8, - 0x00e2ab8c, 0xff7be8e4, 0xffadaad1, 0x01be2047, 0xfc23af19, 0x06e6a752, 0xf43e954f, 0x18e891cc, - 0x36352afd, 0xfb06c0c3, 0xff361dfb, 0x02b346ec, 0xfcd41a1d, 0x02e68351, 0xfdbd59dc, 0x0181dbd3, - 0xff2f0072, 0x0049c4f7, 0x000b5455, 0xffccfd48, 0x00398fbf, 0xffd1f22e, 0x001ba6ff, 0xffef8de9, - 0xfff7d2c9, 0x0007beed, 0x00040748, 0xffe2b924, 0x0049747f, 0xff7b9f11, 0x00c1e2cf, 0xff146ff8, - 0x00e2ab8c, 0xff7be8e4, 0xffadaad1, 0x01be2047, 0xfc23af19, 0x06e6a752, 0xf43e954f, 0x18e891cc, - 0x36352afd, 0xfb06c0c3, 0xff361dfb, 0x02b346ec, 0xfcd41a1d, 0x02e68351, 0xfdbd59dc, 0x0181dbd3, - 0xff2f0072, 0x0049c4f7, 0x000b5455, 0xffccfd48, 0x00398fbf, 0xffd1f22e, 0x001ba6ff, -//Phase 0 - 0xffef8de9, 0x001ba6ff, 0xffd1f22e, 0x00398fbf, 0xffccfd48, 0x000b5455, 0x0049c4f7, 0xff2f0072, - 0x0181dbd3, 0xfdbd59dc, 0x02e68351, 0xfcd41a1d, 0x02b346ec, 0xff361dfb, 0xfb06c0c3, 0x36352afd, - 0x18e891cc, 0xf43e954f, 0x06e6a752, 0xfc23af19, 0x01be2047, 0xffadaad1, 0xff7be8e4, 0x00e2ab8c, - 0xff146ff8, 0x00c1e2cf, 0xff7b9f11, 0x0049747f, 0xffe2b924, 0x00040748, 0x0007beed, 0xfff7d2c9, - 0xffef8de9, 0x001ba6ff, 0xffd1f22e, 0x00398fbf, 0xffccfd48, 0x000b5455, 0x0049c4f7, 0xff2f0072, - 0x0181dbd3, 0xfdbd59dc, 0x02e68351, 0xfcd41a1d, 0x02b346ec, 0xff361dfb, 0xfb06c0c3, 0x36352afd, - 0x18e891cc, 0xf43e954f, 0x06e6a752, 0xfc23af19, 0x01be2047, 0xffadaad1, 0xff7be8e4, 0x00e2ab8c, - 0xff146ff8, 0x00c1e2cf, 0xff7b9f11, 0x0049747f, 0xffe2b924, 0x00040748, 0x0007beed, -}; -const int fir3_div_2_debug[64] = { - -267931, -538891, 253814, 906111, 132004, -1509097, -959342, 1886175, - 2406975, -1671516, -4337783, 371242, 6353255, 2417275, -7718916, -6848455, - 7427526, 12643817, -4328334, -18961170, -2697879, 24330664, 14618659, -26604273, - -32385139, 22651766, 57889705, -6615298, -98612568, -41721758, 208947430, 454727038, - 454727038, 208947430, -41721758, -98612568, -6615298, 57889705, 22651766, -32385139, - -26604273, 14618659, 24330664, -2697879, -18961170, -4328334, 12643817, 7427526, - -6848455, -7718916, 2417275, 6353255, 371242, -4337783, -1671516, 2406975, - 1886175, -959342, -1509097, 132004, 906111, 253814, -538891, -267931, - }; -const int g_third_stage_div_4_fir[252] = { -//Phase 3 - 0x0004b93c, 0xffe146d5, 0x0013baf4, 0xffed51e7, 0x000a477b, 0x00086fb4, 0xffd7cfee, 0x0057198c, - 0xff69777d, 0x00e70e96, 0xfeb74645, 0x01bbfee6, 0xfdbbbcc8, 0x02ef4955, 0xfc0ce536, 0x0695b6d3, - 0x1d4293b2, 0xfed76e38, 0xff8033c6, 0x010600a9, 0xfecf6586, 0x012e3f8a, 0xfeeda46d, 0x00e86204, - 0xff479278, 0x008888a8, 0xffa2f3c2, 0x0038cd95, 0xffe2c273, 0x000aa626, 0xfffe9744, 0xffe94e45, - 0x0004b93c, 0xffe146d5, 0x0013baf4, 0xffed51e7, 0x000a477b, 0x00086fb4, 0xffd7cfee, 0x0057198c, - 0xff69777d, 0x00e70e96, 0xfeb74645, 0x01bbfee6, 0xfdbbbcc8, 0x02ef4955, 0xfc0ce536, 0x0695b6d3, - 0x1d4293b2, 0xfed76e38, 0xff8033c6, 0x010600a9, 0xfecf6586, 0x012e3f8a, 0xfeeda46d, 0x00e86204, - 0xff479278, 0x008888a8, 0xffa2f3c2, 0x0038cd95, 0xffe2c273, 0x000aa626, 0xfffe9744, -//Phase 2 - 0xfffc01a6, 0xffe0fad5, 0x0020fac2, 0xffd49177, 0x00335905, 0xffcb6570, 0x002ab66d, 0xffef33f4, - 0xffe1a781, 0x00687442, 0xff2b7078, 0x016d6118, 0xfdb7ad0b, 0x039cfaa9, 0xf9cd0706, 0x0fec4837, - 0x184ed6ab, 0xfa7031c6, 0x026712ff, 0xfef63f0d, 0x004a866d, 0x00242820, 0xff9f3a00, 0x007b733a, - 0xff811908, 0x00734a8a, 0xffa0d44d, 0x0047c94f, 0xffcecf6c, 0x001e63ba, 0xffeb59af, 0xfff3d33a, - 0xfffc01a6, 0xffe0fad5, 0x0020fac2, 0xffd49177, 0x00335905, 0xffcb6570, 0x002ab66d, 0xffef33f4, - 0xffe1a781, 0x00687442, 0xff2b7078, 0x016d6118, 0xfdb7ad0b, 0x039cfaa9, 0xf9cd0706, 0x0fec4837, - 0x184ed6ab, 0xfa7031c6, 0x026712ff, 0xfef63f0d, 0x004a866d, 0x00242820, 0xff9f3a00, 0x007b733a, - 0xff811908, 0x00734a8a, 0xffa0d44d, 0x0047c94f, 0xffcecf6c, 0x001e63ba, 0xffeb59af, -//Phase 1 - 0xfff3d33a, 0xffeb59af, 0x001e63ba, 0xffcecf6c, 0x0047c94f, 0xffa0d44d, 0x00734a8a, 0xff811908, - 0x007b733a, 0xff9f3a00, 0x00242820, 0x004a866d, 0xfef63f0d, 0x026712ff, 0xfa7031c6, 0x184ed6ab, - 0x0fec4837, 0xf9cd0706, 0x039cfaa9, 0xfdb7ad0b, 0x016d6118, 0xff2b7078, 0x00687442, 0xffe1a781, - 0xffef33f4, 0x002ab66d, 0xffcb6570, 0x00335905, 0xffd49177, 0x0020fac2, 0xffe0fad5, 0xfffc01a6, - 0xfff3d33a, 0xffeb59af, 0x001e63ba, 0xffcecf6c, 0x0047c94f, 0xffa0d44d, 0x00734a8a, 0xff811908, - 0x007b733a, 0xff9f3a00, 0x00242820, 0x004a866d, 0xfef63f0d, 0x026712ff, 0xfa7031c6, 0x184ed6ab, - 0x0fec4837, 0xf9cd0706, 0x039cfaa9, 0xfdb7ad0b, 0x016d6118, 0xff2b7078, 0x00687442, 0xffe1a781, - 0xffef33f4, 0x002ab66d, 0xffcb6570, 0x00335905, 0xffd49177, 0x0020fac2, 0xffe0fad5, -//Phase 0 - 0xffe94e45, 0xfffe9744, 0x000aa626, 0xffe2c273, 0x0038cd95, 0xffa2f3c2, 0x008888a8, 0xff479278, - 0x00e86204, 0xfeeda46d, 0x012e3f8a, 0xfecf6586, 0x010600a9, 0xff8033c6, 0xfed76e38, 0x1d4293b2, - 0x0695b6d3, 0xfc0ce536, 0x02ef4955, 0xfdbbbcc8, 0x01bbfee6, 0xfeb74645, 0x00e70e96, 0xff69777d, - 0x0057198c, 0xffd7cfee, 0x00086fb4, 0x000a477b, 0xffed51e7, 0x0013baf4, 0xffe146d5, 0x0004b93c, - 0xffe94e45, 0xfffe9744, 0x000aa626, 0xffe2c273, 0x0038cd95, 0xffa2f3c2, 0x008888a8, 0xff479278, - 0x00e86204, 0xfeeda46d, 0x012e3f8a, 0xfecf6586, 0x010600a9, 0xff8033c6, 0xfed76e38, 0x1d4293b2, - 0x0695b6d3, 0xfc0ce536, 0x02ef4955, 0xfdbbbcc8, 0x01bbfee6, 0xfeb74645, 0x00e70e96, 0xff69777d, - 0x0057198c, 0xffd7cfee, 0x00086fb4, 0x000a477b, 0xffed51e7, 0x0013baf4, 0xffe146d5, -}; -const int fir3_div_4_debug[128] = { - 154782, -130861, -398947, -743645, -1006741, -1016469, -676648, -46174, - 646522, 1080673, 995805, 348947, -612108, -1423172, -1611850, -958150, - 336829, 1682562, 2352295, 1861322, 276442, -1723720, -3118553, -3048991, - -1316873, 1399606, 3777861, 4473940, 2854086, -550406, -4158332, -6043332, - -4932673, -994367, 4045213, 7614722, 7571275, 3422753, -3171072, -8990153, - -10771677, -6965188, 1184784, 9904069, 14548851, 11972748, 2442038, -9981245, - -19014044, -19147130, -8708217, 8585300, 24618154, 30309716, 20154751, -4187677, - -33131877, -52001917, -46655261, -9717988, 55237481, 133571611, 203909973, 245451225, - 245451225, 203909973, 133571611, 55237481, -9717988, -46655261, -52001917, -33131877, - -4187677, 20154751, 30309716, 24618154, 8585300, -8708217, -19147130, -19014044, - -9981245, 2442038, 11972748, 14548851, 9904069, 1184784, -6965188, -10771677, - -8990153, -3171072, 3422753, 7571275, 7614722, 4045213, -994367, -4932673, - -6043332, -4158332, -550406, 2854086, 4473940, 3777861, 1399606, -1316873, - -3048991, -3118553, -1723720, 276442, 1861322, 2352295, 1682562, 336829, - -958150, -1611850, -1423172, -612108, 348947, 995805, 1080673, 646522, - -46174, -676648, -1016469, -1006741, -743645, -398947, -130861, 154782, - }; -const int g_third_stage_div_6_fir[378] = { -//Phase 5 - 0x00056b0b, 0xffec4271, 0x000ab85d, 0xfff7114f, 0x0001ac8b, 0x000c872a, 0xffdcd208, 0x00434fce, - 0xff92a99c, 0x00a103b7, 0xff226ab2, 0x01223a34, 0xfe90bfd9, 0x01c962c9, 0xfdb96f67, 0x036bfaa7, - 0x13cf57fd, 0xfff38db5, 0xff482b9c, 0x00ec0041, 0xff0dc9ac, 0x00e1a4a1, 0xff3b830c, 0x00a12152, - 0xff83c10b, 0x005954d9, 0xffc5293c, 0x0022402d, 0xffefdfa2, 0x00044ec3, 0x0001234a, 0xfff00920, - 0x00056b0b, 0xffec4271, 0x000ab85d, 0xfff7114f, 0x0001ac8b, 0x000c872a, 0xffdcd208, 0x00434fce, - 0xff92a99c, 0x00a103b7, 0xff226ab2, 0x01223a34, 0xfe90bfd9, 0x01c962c9, 0xfdb96f67, 0x036bfaa7, - 0x13cf57fd, 0xfff38db5, 0xff482b9c, 0x00ec0041, 0xff0dc9ac, 0x00e1a4a1, 0xff3b830c, 0x00a12152, - 0xff83c10b, 0x005954d9, 0xffc5293c, 0x0022402d, 0xffefdfa2, 0x00044ec3, 0x0001234a, -//Phase 4 - 0xffff9433, 0xffea8d5f, 0x001279c0, 0xffea56a3, 0x00152924, 0xfff16cd0, 0xffff5ddf, 0x001af2fc, - 0xffbd4f63, 0x007a0de7, 0xff3c8068, 0x0122e2c6, 0xfe5f4847, 0x02547782, 0xfc6e3736, 0x077d3344, - 0x1248152e, 0xfd6e5ae1, 0x00bf2a27, 0xfff54c43, 0xffb3a3be, 0x007519a2, 0xff7dd845, 0x007dadc7, - 0xff917c11, 0x0059cafc, 0xffbc8e55, 0x002e6234, 0xffe36edb, 0x000f24c4, 0xfff7c2dd, 0xfff4cafd, - 0xffff9433, 0xffea8d5f, 0x001279c0, 0xffea56a3, 0x00152924, 0xfff16cd0, 0xffff5ddf, 0x001af2fc, - 0xffbd4f63, 0x007a0de7, 0xff3c8068, 0x0122e2c6, 0xfe5f4847, 0x02547782, 0xfc6e3736, 0x077d3344, - 0x1248152e, 0xfd6e5ae1, 0x00bf2a27, 0xfff54c43, 0xffb3a3be, 0x007519a2, 0xff7dd845, 0x007dadc7, - 0xff917c11, 0x0059cafc, 0xffbc8e55, 0x002e6234, 0xffe36edb, 0x000f24c4, 0xfff7c2dd, -//Phase 3 - 0xfffd39ae, 0xffebc62f, 0x0016852f, 0xffe14178, 0x0025cee3, 0xffd6e958, 0x00258eaa, 0xffe835e9, - 0xfffc0293, 0x003208ec, 0xff885579, 0x00dcfeab, 0xfe8dff27, 0x025fd820, 0xfbc44ffe, 0x0bac480b, - 0x0f704c5a, 0xfc0a2dd4, 0x01d58c4e, 0xff1cf28c, 0x005a2d0b, 0xfff86104, 0xffd73fd0, 0x004182ab, - 0xffb65924, 0x004687a0, 0xffc37859, 0x002f40e6, 0xffde7937, 0x001584ad, 0xfff04854, 0xfff976f5, - 0xfffd39ae, 0xffebc62f, 0x0016852f, 0xffe14178, 0x0025cee3, 0xffd6e958, 0x00258eaa, 0xffe835e9, - 0xfffc0293, 0x003208ec, 0xff885579, 0x00dcfeab, 0xfe8dff27, 0x025fd820, 0xfbc44ffe, 0x0bac480b, - 0x0f704c5a, 0xfc0a2dd4, 0x01d58c4e, 0xff1cf28c, 0x005a2d0b, 0xfff86104, 0xffd73fd0, 0x004182ab, - 0xffb65924, 0x004687a0, 0xffc37859, 0x002f40e6, 0xffde7937, 0x001584ad, 0xfff04854, -//Phase 2 - 0xfff976f5, 0xfff04854, 0x001584ad, 0xffde7937, 0x002f40e6, 0xffc37859, 0x004687a0, 0xffb65924, - 0x004182ab, 0xffd73fd0, 0xfff86104, 0x005a2d0b, 0xff1cf28c, 0x01d58c4e, 0xfc0a2dd4, 0x0f704c5a, - 0x0bac480b, 0xfbc44ffe, 0x025fd820, 0xfe8dff27, 0x00dcfeab, 0xff885579, 0x003208ec, 0xfffc0293, - 0xffe835e9, 0x00258eaa, 0xffd6e958, 0x0025cee3, 0xffe14178, 0x0016852f, 0xffebc62f, 0xfffd39ae, - 0xfff976f5, 0xfff04854, 0x001584ad, 0xffde7937, 0x002f40e6, 0xffc37859, 0x004687a0, 0xffb65924, - 0x004182ab, 0xffd73fd0, 0xfff86104, 0x005a2d0b, 0xff1cf28c, 0x01d58c4e, 0xfc0a2dd4, 0x0f704c5a, - 0x0bac480b, 0xfbc44ffe, 0x025fd820, 0xfe8dff27, 0x00dcfeab, 0xff885579, 0x003208ec, 0xfffc0293, - 0xffe835e9, 0x00258eaa, 0xffd6e958, 0x0025cee3, 0xffe14178, 0x0016852f, 0xffebc62f, -//Phase 1 - 0xfff4cafd, 0xfff7c2dd, 0x000f24c4, 0xffe36edb, 0x002e6234, 0xffbc8e55, 0x0059cafc, 0xff917c11, - 0x007dadc7, 0xff7dd845, 0x007519a2, 0xffb3a3be, 0xfff54c43, 0x00bf2a27, 0xfd6e5ae1, 0x1248152e, - 0x077d3344, 0xfc6e3736, 0x02547782, 0xfe5f4847, 0x0122e2c6, 0xff3c8068, 0x007a0de7, 0xffbd4f63, - 0x001af2fc, 0xffff5ddf, 0xfff16cd0, 0x00152924, 0xffea56a3, 0x001279c0, 0xffea8d5f, 0xffff9433, - 0xfff4cafd, 0xfff7c2dd, 0x000f24c4, 0xffe36edb, 0x002e6234, 0xffbc8e55, 0x0059cafc, 0xff917c11, - 0x007dadc7, 0xff7dd845, 0x007519a2, 0xffb3a3be, 0xfff54c43, 0x00bf2a27, 0xfd6e5ae1, 0x1248152e, - 0x077d3344, 0xfc6e3736, 0x02547782, 0xfe5f4847, 0x0122e2c6, 0xff3c8068, 0x007a0de7, 0xffbd4f63, - 0x001af2fc, 0xffff5ddf, 0xfff16cd0, 0x00152924, 0xffea56a3, 0x001279c0, 0xffea8d5f, -//Phase 0 - 0xfff00920, 0x0001234a, 0x00044ec3, 0xffefdfa2, 0x0022402d, 0xffc5293c, 0x005954d9, 0xff83c10b, - 0x00a12152, 0xff3b830c, 0x00e1a4a1, 0xff0dc9ac, 0x00ec0041, 0xff482b9c, 0xfff38db5, 0x13cf57fd, - 0x036bfaa7, 0xfdb96f67, 0x01c962c9, 0xfe90bfd9, 0x01223a34, 0xff226ab2, 0x00a103b7, 0xff92a99c, - 0x00434fce, 0xffdcd208, 0x000c872a, 0x0001ac8b, 0xfff7114f, 0x000ab85d, 0xffec4271, 0x00056b0b, - 0xfff00920, 0x0001234a, 0x00044ec3, 0xffefdfa2, 0x0022402d, 0xffc5293c, 0x005954d9, 0xff83c10b, - 0x00a12152, 0xff3b830c, 0x00e1a4a1, 0xff0dc9ac, 0x00ec0041, 0xff482b9c, 0xfff38db5, 0x13cf57fd, - 0x036bfaa7, 0xfdb96f67, 0x01c962c9, 0xfe90bfd9, 0x01223a34, 0xff226ab2, 0x00a103b7, 0xff92a99c, - 0x00434fce, 0xffdcd208, 0x000c872a, 0x0001ac8b, 0xfff7114f, 0x000ab85d, 0xffec4271, -}; -const int fir3_div_6_debug[192] = { - 177541, -13798, -90921, -214149, -367233, -523120, -646855, -702800, - -662760, -515030, -269969, 37285, 351278, 605408, 737943, 705110, - 496226, 141153, -292696, -709806, -1007428, -1098596, -936082, -528431, - 54853, 693394, 1238897, 1548403, 1519898, 1122326, 410517, -477592, - -1346388, -1983443, -2210005, -1928034, -1152764, -20752, 1230677, 2311120, - 2942334, 2927212, 2205671, 883070, -779531, -2413422, -3621367, -4071290, - -3582770, -2185294, -130742, 2146645, 4118243, 5279913, 5276123, 3999475, - 1639542, -1335320, -4264925, -6438522, -7260839, -6406092, -3921219, -249726, - 3837137, 7393872, 9510170, 9531747, 7241557, 2954885, -2502177, -7936810, - -12034067, -13655004, -12124268, -7440058, -350686, 7733280, 14987620, 19545025, - 19917840, 15386151, 6264083, -6023730, -19089484, -29942885, -35510273, -33220886, - -21549711, -407845, 28704083, 62822818, 97920005, 129508909, 153356951, 166177790, - 166177790, 153356951, 129508909, 97920005, 62822818, 28704083, -407845, -21549711, - -33220886, -35510273, -29942885, -19089484, -6023730, 6264083, 15386151, 19917840, - 19545025, 14987620, 7733280, -350686, -7440058, -12124268, -13655004, -12034067, - -7936810, -2502177, 2954885, 7241557, 9531747, 9510170, 7393872, 3837137, - -249726, -3921219, -6406092, -7260839, -6438522, -4264925, -1335320, 1639542, - 3999475, 5276123, 5279913, 4118243, 2146645, -130742, -2185294, -3582770, - -4071290, -3621367, -2413422, -779531, 883070, 2205671, 2927212, 2942334, - 2311120, 1230677, -20752, -1152764, -1928034, -2210005, -1983443, -1346388, - -477592, 410517, 1122326, 1519898, 1548403, 1238897, 693394, 54853, - -528431, -936082, -1098596, -1007428, -709806, -292696, 141153, 496226, - 705110, 737943, 605408, 351278, 37285, -269969, -515030, -662760, - -702800, -646855, -523120, -367233, -214149, -90921, -13798, 177541, - }; -const int g_third_stage_div_8_fir[504] = { -//Phase 7 - 0x000584f2, 0xfff19a32, 0x000707bd, 0xfffaaad7, 0xffff55da, 0x000bd8ed, 0xffe2caa1, 0x003560a1, - 0xffab869f, 0x007a16ea, 0xff5aa12f, 0x00d54cff, 0xfef69896, 0x01439dbf, 0xfe70af4b, 0x0233a716, - 0x0ee02028, 0x00408971, 0xff51440b, 0x00c6cf58, 0xff3d2948, 0x00b0c838, 0xff68e697, 0x007a08b6, - 0xffa33a32, 0x0041b480, 0xffd583a4, 0x00180e21, 0xfff55149, 0x00021fe2, 0x0001a126, 0xfff3c6a3, - 0x000584f2, 0xfff19a32, 0x000707bd, 0xfffaaad7, 0xffff55da, 0x000bd8ed, 0xffe2caa1, 0x003560a1, - 0xffab869f, 0x007a16ea, 0xff5aa12f, 0x00d54cff, 0xfef69896, 0x01439dbf, 0xfe70af4b, 0x0233a716, - 0x0ee02028, 0x00408971, 0xff51440b, 0x00c6cf58, 0xff3d2948, 0x00b0c838, 0xff68e697, 0x007a08b6, - 0xffa33a32, 0x0041b480, 0xffd583a4, 0x00180e21, 0xfff55149, 0x00021fe2, 0x0001a126, -//Phase 6 - 0x00004fc4, 0xfff03da5, 0x000bcbaf, 0xfff33e05, 0x000a505f, 0xfffd0e7a, 0xfff503f3, 0x0020f428, - 0xffbfd1ff, 0x0069a037, 0xff61c7c4, 0x00df8620, 0xfece6e1c, 0x01a08579, 0xfda761ac, 0x046d3cfa, - 0x0e396273, 0xfeb0a160, 0x002c0e73, 0x003c506c, 0xff96fedd, 0x00786007, 0xff896374, 0x006a8834, - 0xffa73114, 0x0044ecf0, 0xffce8181, 0x002057f8, 0xffed6df6, 0x0008aebf, 0xfffc3976, 0xfff66966, - 0x00004fc4, 0xfff03da5, 0x000bcbaf, 0xfff33e05, 0x000a505f, 0xfffd0e7a, 0xfff503f3, 0x0020f428, - 0xffbfd1ff, 0x0069a037, 0xff61c7c4, 0x00df8620, 0xfece6e1c, 0x01a08579, 0xfda761ac, 0x046d3cfa, - 0x0e396273, 0xfeb0a160, 0x002c0e73, 0x003c506c, 0xff96fedd, 0x00786007, 0xff896374, 0x006a8834, - 0xffa73114, 0x0044ecf0, 0xffce8181, 0x002057f8, 0xffed6df6, 0x0008aebf, 0xfffc3976, -//Phase 5 - 0xffff65b9, 0xfff0016d, 0x000f45ff, 0xffecdaf0, 0x0014d8b3, 0xffed7a66, 0x000a176d, 0x00069e57, - 0xffde32bb, 0x0049bbaf, 0xff7ee3b6, 0x00cc1b37, 0xfecca676, 0x01cdaed5, 0xfd1395b5, 0x06c849cd, - 0x0cf924a7, 0xfd9638a4, 0x00e80171, 0xffb65fd3, 0xfff76b32, 0x00348bda, 0xffb6cc19, 0x004e8aa7, - 0xffb61d2f, 0x003f402c, 0xffce3324, 0x0023f8ff, 0xffe87c55, 0x000d9af1, 0xfff7646e, 0xfff92826, - 0xffff65b9, 0xfff0016d, 0x000f45ff, 0xffecdaf0, 0x0014d8b3, 0xffed7a66, 0x000a176d, 0x00069e57, - 0xffde32bb, 0x0049bbaf, 0xff7ee3b6, 0x00cc1b37, 0xfecca676, 0x01cdaed5, 0xfd1395b5, 0x06c849cd, - 0x0cf924a7, 0xfd9638a4, 0x00e80171, 0xffb65fd3, 0xfff76b32, 0x00348bda, 0xffb6cc19, 0x004e8aa7, - 0xffb61d2f, 0x003f402c, 0xffce3324, 0x0023f8ff, 0xffe87c55, 0x000d9af1, 0xfff7646e, -//Phase 4 - 0xfffdd732, 0xfff119bd, 0x0010ef55, 0xffe87774, 0x001d77aa, 0xffdf2a17, 0x001f609f, 0xffe9838d, - 0x00033f2d, 0x001daa0a, 0xffaf91bd, 0x009b7048, 0xfef4cafe, 0x01bfdde7, 0xfcd17d7e, 0x091aa07e, - 0x0b389efa, 0xfcf8115d, 0x0172516c, 0xff451d2a, 0x0051de56, 0xffee9f6a, 0xffea8ab9, 0x002a69bd, - 0xffcd62f4, 0x0032011e, 0xffd4275a, 0x0022d803, 0xffe6da1a, 0x00106a02, 0xfff39955, 0xfffbb63b, - 0xfffdd732, 0xfff119bd, 0x0010ef55, 0xffe87774, 0x001d77aa, 0xffdf2a17, 0x001f609f, 0xffe9838d, - 0x00033f2d, 0x001daa0a, 0xffaf91bd, 0x009b7048, 0xfef4cafe, 0x01bfdde7, 0xfcd17d7e, 0x091aa07e, - 0x0b389efa, 0xfcf8115d, 0x0172516c, 0xff451d2a, 0x0051de56, 0xffee9f6a, 0xffea8ab9, 0x002a69bd, - 0xffcd62f4, 0x0032011e, 0xffd4275a, 0x0022d803, 0xffe6da1a, 0x00106a02, 0xfff39955, -//Phase 3 - 0xfffbb63b, 0xfff39955, 0x00106a02, 0xffe6da1a, 0x0022d803, 0xffd4275a, 0x0032011e, 0xffcd62f4, - 0x002a69bd, 0xffea8ab9, 0xffee9f6a, 0x0051de56, 0xff451d2a, 0x0172516c, 0xfcf8115d, 0x0b389efa, - 0x091aa07e, 0xfcd17d7e, 0x01bfdde7, 0xfef4cafe, 0x009b7048, 0xffaf91bd, 0x001daa0a, 0x00033f2d, - 0xffe9838d, 0x001f609f, 0xffdf2a17, 0x001d77aa, 0xffe87774, 0x0010ef55, 0xfff119bd, 0xfffdd732, - 0xfffbb63b, 0xfff39955, 0x00106a02, 0xffe6da1a, 0x0022d803, 0xffd4275a, 0x0032011e, 0xffcd62f4, - 0x002a69bd, 0xffea8ab9, 0xffee9f6a, 0x0051de56, 0xff451d2a, 0x0172516c, 0xfcf8115d, 0x0b389efa, - 0x091aa07e, 0xfcd17d7e, 0x01bfdde7, 0xfef4cafe, 0x009b7048, 0xffaf91bd, 0x001daa0a, 0x00033f2d, - 0xffe9838d, 0x001f609f, 0xffdf2a17, 0x001d77aa, 0xffe87774, 0x0010ef55, 0xfff119bd, -//Phase 2 - 0xfff92826, 0xfff7646e, 0x000d9af1, 0xffe87c55, 0x0023f8ff, 0xffce3324, 0x003f402c, 0xffb61d2f, - 0x004e8aa7, 0xffb6cc19, 0x00348bda, 0xfff76b32, 0xffb65fd3, 0x00e80171, 0xfd9638a4, 0x0cf924a7, - 0x06c849cd, 0xfd1395b5, 0x01cdaed5, 0xfecca676, 0x00cc1b37, 0xff7ee3b6, 0x0049bbaf, 0xffde32bb, - 0x00069e57, 0x000a176d, 0xffed7a66, 0x0014d8b3, 0xffecdaf0, 0x000f45ff, 0xfff0016d, 0xffff65b9, - 0xfff92826, 0xfff7646e, 0x000d9af1, 0xffe87c55, 0x0023f8ff, 0xffce3324, 0x003f402c, 0xffb61d2f, - 0x004e8aa7, 0xffb6cc19, 0x00348bda, 0xfff76b32, 0xffb65fd3, 0x00e80171, 0xfd9638a4, 0x0cf924a7, - 0x06c849cd, 0xfd1395b5, 0x01cdaed5, 0xfecca676, 0x00cc1b37, 0xff7ee3b6, 0x0049bbaf, 0xffde32bb, - 0x00069e57, 0x000a176d, 0xffed7a66, 0x0014d8b3, 0xffecdaf0, 0x000f45ff, 0xfff0016d, -//Phase 1 - 0xfff66966, 0xfffc3976, 0x0008aebf, 0xffed6df6, 0x002057f8, 0xffce8181, 0x0044ecf0, 0xffa73114, - 0x006a8834, 0xff896374, 0x00786007, 0xff96fedd, 0x003c506c, 0x002c0e73, 0xfeb0a160, 0x0e396273, - 0x046d3cfa, 0xfda761ac, 0x01a08579, 0xfece6e1c, 0x00df8620, 0xff61c7c4, 0x0069a037, 0xffbfd1ff, - 0x0020f428, 0xfff503f3, 0xfffd0e7a, 0x000a505f, 0xfff33e05, 0x000bcbaf, 0xfff03da5, 0x00004fc4, - 0xfff66966, 0xfffc3976, 0x0008aebf, 0xffed6df6, 0x002057f8, 0xffce8181, 0x0044ecf0, 0xffa73114, - 0x006a8834, 0xff896374, 0x00786007, 0xff96fedd, 0x003c506c, 0x002c0e73, 0xfeb0a160, 0x0e396273, - 0x046d3cfa, 0xfda761ac, 0x01a08579, 0xfece6e1c, 0x00df8620, 0xff61c7c4, 0x0069a037, 0xffbfd1ff, - 0x0020f428, 0xfff503f3, 0xfffd0e7a, 0x000a505f, 0xfff33e05, 0x000bcbaf, 0xfff03da5, -//Phase 0 - 0xfff3c6a3, 0x0001a126, 0x00021fe2, 0xfff55149, 0x00180e21, 0xffd583a4, 0x0041b480, 0xffa33a32, - 0x007a08b6, 0xff68e697, 0x00b0c838, 0xff3d2948, 0x00c6cf58, 0xff51440b, 0x00408971, 0x0ee02028, - 0x0233a716, 0xfe70af4b, 0x01439dbf, 0xfef69896, 0x00d54cff, 0xff5aa12f, 0x007a16ea, 0xffab869f, - 0x003560a1, 0xffe2caa1, 0x000bd8ed, 0xffff55da, 0xfffaaad7, 0x000707bd, 0xfff19a32, 0x000584f2, - 0xfff3c6a3, 0x0001a126, 0x00021fe2, 0xfff55149, 0x00180e21, 0xffd583a4, 0x0041b480, 0xffa33a32, - 0x007a08b6, 0xff68e697, 0x00b0c838, 0xff3d2948, 0x00c6cf58, 0xff51440b, 0x00408971, 0x0ee02028, - 0x0233a716, 0xfe70af4b, 0x01439dbf, 0xfef69896, 0x00d54cff, 0xff5aa12f, 0x007a16ea, 0xffab869f, - 0x003560a1, 0xffe2caa1, 0x000bd8ed, 0xffff55da, 0xfffaaad7, 0x000707bd, 0xfff19a32, -}; -const int fir3_div_8_debug[256] = { - 180857, 10210, -19747, -70759, -140514, -224237, -314189, -400558, - -471783, -516397, -524105, -488225, -406357, -282057, -123717, 53395, - 230366, 386519, 500479, 554922, 537857, 445816, 284511, 69617, - -174740, -418045, -627336, -771142, -824051, -770517, -608517, -350043, - -21779, 337967, 683097, 965589, 1141761, 1178751, 1059836, 788240, - 388214, -96451, -606925, -1075956, -1436755, -1631854, -1621823, -1392174, - -957103, -359942, 330678, 1028175, 1638543, 2072598, 2258552, 2153024, - 1749072, 1079828, 216875, -736825, -1658502, -2421096, -2910070, -3039975, - -2768048, -2103040, -1107618, 106390, 1389790, 2573651, 3490842, 3998811, - 4000629, 3461147, 2416087, 972037, -703139, -2398707, -3886662, -4951220, - -5418856, -5184542, -4230693, -2635553, -569419, 1721837, 3944451, 5792796, - 6989439, 7324432, 6688155, 5093412, 2682667, -281191, -3440785, -6384476, - -8696757, -10012914, -10071237, -8755841, -6123883, -2412566, 1976374, 6514604, - 10604255, 13648572, 15128426, 14675699, 12134582, 7602360, 1443641, -5725690, - -13084762, -19681066, -24524069, -26689857, -25425745, -20243374, -10989392, 2114744, - 18469771, 37133949, 56894694, 76369983, 94130045, 108827219, 119320889, 124784660, - 124784660, 119320889, 108827219, 94130045, 76369983, 56894694, 37133949, 18469771, - 2114744, -10989392, -20243374, -25425745, -26689857, -24524069, -19681066, -13084762, - -5725690, 1443641, 7602360, 12134582, 14675699, 15128426, 13648572, 10604255, - 6514604, 1976374, -2412566, -6123883, -8755841, -10071237, -10012914, -8696757, - -6384476, -3440785, -281191, 2682667, 5093412, 6688155, 7324432, 6989439, - 5792796, 3944451, 1721837, -569419, -2635553, -4230693, -5184542, -5418856, - -4951220, -3886662, -2398707, -703139, 972037, 2416087, 3461147, 4000629, - 3998811, 3490842, 2573651, 1389790, 106390, -1107618, -2103040, -2768048, - -3039975, -2910070, -2421096, -1658502, -736825, 216875, 1079828, 1749072, - 2153024, 2258552, 2072598, 1638543, 1028175, 330678, -359942, -957103, - -1392174, -1621823, -1631854, -1436755, -1075956, -606925, -96451, 388214, - 788240, 1059836, 1178751, 1141761, 965589, 683097, 337967, -21779, - -350043, -608517, -770517, -824051, -771142, -627336, -418045, -174740, - 69617, 284511, 445816, 537857, 554922, 500479, 386519, 230366, - 53395, -123717, -282057, -406357, -488225, -524105, -516397, -471783, - -400558, -314189, -224237, -140514, -70759, -19747, 10210, 180857, - }; -const int g_third_stage_div_12_fir[756] = { -//Phase 11 - 0x000581df, 0xfff6b054, 0x000400be, 0xfffd5b3f, 0xfffe4a26, 0x00097f96, 0xffeab5af, 0x002568a8, - 0xffc62fea, 0x005213df, 0xff928c77, 0x008affed, 0xff560d09, 0x00ca8e4e, 0xff0ecd64, 0x013bb300, - 0x09eea069, 0x005dec6f, 0xff72c811, 0x0092f331, 0xff7585cf, 0x007aae2f, 0xff98f631, 0x0051ffd3, - 0xffc2899a, 0x002adce9, 0xffe4d243, 0x000eeb91, 0xfff9d534, 0x0000acd2, 0x00019732, 0xfff7ad5a, - 0x000581df, 0xfff6b054, 0x000400be, 0xfffd5b3f, 0xfffe4a26, 0x00097f96, 0xffeab5af, 0x002568a8, - 0xffc62fea, 0x005213df, 0xff928c77, 0x008affed, 0xff560d09, 0x00ca8e4e, 0xff0ecd64, 0x013bb300, - 0x09eea069, 0x005dec6f, 0xff72c811, 0x0092f331, 0xff7585cf, 0x007aae2f, 0xff98f631, 0x0051ffd3, - 0xffc2899a, 0x002adce9, 0xffe4d243, 0x000eeb91, 0xfff9d534, 0x0000acd2, 0x00019732, -//Phase 10 - 0x00008746, 0xfff5eb41, 0x00064314, 0xfff9fe1d, 0x00031a3d, 0x000338c9, 0xfff22933, 0x001d766c, - 0xffcd75dc, 0x004d3f17, 0xff9266da, 0x0093c335, 0xff3f1c18, 0x00f9932c, 0xfeb03144, 0x02300fed, - 0x09bcd3e9, 0xff9c6f1a, 0xffd65b49, 0x0056620c, 0xff9b4e21, 0x006415dc, 0xffa4ff99, 0x004d3aba, - 0xffc28f99, 0x002da046, 0xffe0c1ef, 0x0013397b, 0xfff5f74b, 0x0003c35d, 0xffff26f1, 0xfff8d1c1, - 0x00008746, 0xfff5eb41, 0x00064314, 0xfff9fe1d, 0x00031a3d, 0x000338c9, 0xfff22933, 0x001d766c, - 0xffcd75dc, 0x004d3f17, 0xff9266da, 0x0093c335, 0xff3f1c18, 0x00f9932c, 0xfeb03144, 0x02300fed, - 0x09bcd3e9, 0xff9c6f1a, 0xffd65b49, 0x0056620c, 0xff9b4e21, 0x006415dc, 0xffa4ff99, 0x004d3aba, - 0xffc28f99, 0x002da046, 0xffe0c1ef, 0x0013397b, 0xfff5f74b, 0x0003c35d, 0xffff26f1, -//Phase 9 - 0x00004ddd, 0xfff5737c, 0x00083c34, 0xfff6c7fb, 0x0008012c, 0xfffc6c11, 0xfffacec5, 0x001361a9, - 0xffd8167a, 0x0043928a, 0xff98d1c6, 0x00941355, 0xff328920, 0x011ca417, 0xfe5cf355, 0x03342865, - 0x095affbe, 0xfefb943a, 0x00343b60, 0x0018889c, 0xffc4f01d, 0x0048cad1, 0xffb5b905, 0x00443e9a, - 0xffc6181c, 0x002da9dc, 0xffdea992, 0x001638f1, 0xfff2dfae, 0x000675ef, 0xfffccfb2, 0xfffa09d0, - 0x00004ddd, 0xfff5737c, 0x00083c34, 0xfff6c7fb, 0x0008012c, 0xfffc6c11, 0xfffacec5, 0x001361a9, - 0xffd8167a, 0x0043928a, 0xff98d1c6, 0x00941355, 0xff328920, 0x011ca417, 0xfe5cf355, 0x03342865, - 0x095affbe, 0xfefb943a, 0x00343b60, 0x0018889c, 0xffc4f01d, 0x0048cad1, 0xffb5b905, 0x00443e9a, - 0xffc6181c, 0x002da9dc, 0xffdea992, 0x001638f1, 0xfff2dfae, 0x000675ef, 0xfffccfb2, -//Phase 8 - 0xffffe482, 0xfff5518a, 0x0009cd49, 0xfff3ec8c, 0x000cb50e, 0xfff57a65, 0x000430ef, 0x0007ab10, - 0xffe5964b, 0x00356a1c, 0xffa5b8c8, 0x008b80e7, 0xff31a7c2, 0x0130da78, 0xfe1b05ed, 0x0440397a, - 0x08cc9a58, 0xfe7e3a7f, 0x0087cf44, 0xffdcef04, 0xffefde12, 0x002a92bf, 0xffc9f8fa, 0x0037be23, - 0xffccc79b, 0x002b1912, 0xffde8f60, 0x0017cfc6, 0xfff0b084, 0x0008a30e, 0xfffaabe7, 0xfffb4624, - 0xffffe482, 0xfff5518a, 0x0009cd49, 0xfff3ec8c, 0x000cb50e, 0xfff57a65, 0x000430ef, 0x0007ab10, - 0xffe5964b, 0x00356a1c, 0xffa5b8c8, 0x008b80e7, 0xff31a7c2, 0x0130da78, 0xfe1b05ed, 0x0440397a, - 0x08cc9a58, 0xfe7e3a7f, 0x0087cf44, 0xffdcef04, 0xffefde12, 0x002a92bf, 0xffc9f8fa, 0x0037be23, - 0xffccc79b, 0x002b1912, 0xffde8f60, 0x0017cfc6, 0xfff0b084, 0x0008a30e, 0xfffaabe7, -//Phase 7 - 0xffff4af2, 0xfff591fe, 0x000ada7a, 0xfff19c99, 0x0010eb1e, 0xffeecc49, 0x000dc918, 0xfffaf275, - 0xfff547fe, 0x00236a9c, 0xffb8a386, 0x007a1e06, 0xff3d2e42, 0x0133f7ad, 0xfdf004aa, 0x054be40a, - 0x0816a601, 0xfe25b641, 0x00cd5d3e, 0xffa6c97b, 0x00199826, 0x000b4940, 0xffe06f53, 0x002897b1, - 0xffd61871, 0x0026322e, 0xffe05c07, 0x0017f9a4, 0xffef7c89, 0x000a332d, 0xfff8d337, 0xfffc762e, - 0xffff4af2, 0xfff591fe, 0x000ada7a, 0xfff19c99, 0x0010eb1e, 0xffeecc49, 0x000dc918, 0xfffaf275, - 0xfff547fe, 0x00236a9c, 0xffb8a386, 0x007a1e06, 0xff3d2e42, 0x0133f7ad, 0xfdf004aa, 0x054be40a, - 0x0816a601, 0xfe25b641, 0x00cd5d3e, 0xffa6c97b, 0x00199826, 0x000b4940, 0xffe06f53, 0x002897b1, - 0xffd61871, 0x0026322e, 0xffe05c07, 0x0017f9a4, 0xffef7c89, 0x000a332d, 0xfff8d337, -//Phase 6 - 0xfffe81a5, 0xfff63f01, 0x000b4e16, 0xfff0042a, 0x00145bb9, 0xffe8cbaa, 0x00170704, 0xffedeee7, - 0x000654af, 0x000e7b1c, 0xffd0b830, 0x006083b4, 0xff5522b2, 0x01248fb8, 0xfde0ebc3, 0x064e8105, - 0x073f7a97, 0xfdf1d3ff, 0x01022b03, 0xff78d09e, 0x003fcf3c, 0xffecc3fb, 0xfff7ba3a, 0x0017c6cf, - 0xffe1642b, 0x001f585b, 0xffe3dda3, 0x0016c721, 0xffef468c, 0x000b1781, 0xfff7554e, 0xfffd8de2, - 0xfffe81a5, 0xfff63f01, 0x000b4e16, 0xfff0042a, 0x00145bb9, 0xffe8cbaa, 0x00170704, 0xffedeee7, - 0x000654af, 0x000e7b1c, 0xffd0b830, 0x006083b4, 0xff5522b2, 0x01248fb8, 0xfde0ebc3, 0x064e8105, - 0x073f7a97, 0xfdf1d3ff, 0x01022b03, 0xff78d09e, 0x003fcf3c, 0xffecc3fb, 0xfff7ba3a, 0x0017c6cf, - 0xffe1642b, 0x001f585b, 0xffe3dda3, 0x0016c721, 0xffef468c, 0x000b1781, 0xfff7554e, -//Phase 5 - 0xfffd8de2, 0xfff7554e, 0x000b1781, 0xffef468c, 0x0016c721, 0xffe3dda3, 0x001f585b, 0xffe1642b, - 0x0017c6cf, 0xfff7ba3a, 0xffecc3fb, 0x003fcf3c, 0xff78d09e, 0x01022b03, 0xfdf1d3ff, 0x073f7a97, - 0x064e8105, 0xfde0ebc3, 0x01248fb8, 0xff5522b2, 0x006083b4, 0xffd0b830, 0x000e7b1c, 0x000654af, - 0xffedeee7, 0x00170704, 0xffe8cbaa, 0x00145bb9, 0xfff0042a, 0x000b4e16, 0xfff63f01, 0xfffe81a5, - 0xfffd8de2, 0xfff7554e, 0x000b1781, 0xffef468c, 0x0016c721, 0xffe3dda3, 0x001f585b, 0xffe1642b, - 0x0017c6cf, 0xfff7ba3a, 0xffecc3fb, 0x003fcf3c, 0xff78d09e, 0x01022b03, 0xfdf1d3ff, 0x073f7a97, - 0x064e8105, 0xfde0ebc3, 0x01248fb8, 0xff5522b2, 0x006083b4, 0xffd0b830, 0x000e7b1c, 0x000654af, - 0xffedeee7, 0x00170704, 0xffe8cbaa, 0x00145bb9, 0xfff0042a, 0x000b4e16, 0xfff63f01, -//Phase 4 - 0xfffc762e, 0xfff8d337, 0x000a332d, 0xffef7c89, 0x0017f9a4, 0xffe05c07, 0x0026322e, 0xffd61871, - 0x002897b1, 0xffe06f53, 0x000b4940, 0x00199826, 0xffa6c97b, 0x00cd5d3e, 0xfe25b641, 0x0816a601, - 0x054be40a, 0xfdf004aa, 0x0133f7ad, 0xff3d2e42, 0x007a1e06, 0xffb8a386, 0x00236a9c, 0xfff547fe, - 0xfffaf275, 0x000dc918, 0xffeecc49, 0x0010eb1e, 0xfff19c99, 0x000ada7a, 0xfff591fe, 0xffff4af2, - 0xfffc762e, 0xfff8d337, 0x000a332d, 0xffef7c89, 0x0017f9a4, 0xffe05c07, 0x0026322e, 0xffd61871, - 0x002897b1, 0xffe06f53, 0x000b4940, 0x00199826, 0xffa6c97b, 0x00cd5d3e, 0xfe25b641, 0x0816a601, - 0x054be40a, 0xfdf004aa, 0x0133f7ad, 0xff3d2e42, 0x007a1e06, 0xffb8a386, 0x00236a9c, 0xfff547fe, - 0xfffaf275, 0x000dc918, 0xffeecc49, 0x0010eb1e, 0xfff19c99, 0x000ada7a, 0xfff591fe, -//Phase 3 - 0xfffb4624, 0xfffaabe7, 0x0008a30e, 0xfff0b084, 0x0017cfc6, 0xffde8f60, 0x002b1912, 0xffccc79b, - 0x0037be23, 0xffc9f8fa, 0x002a92bf, 0xffefde12, 0xffdcef04, 0x0087cf44, 0xfe7e3a7f, 0x08cc9a58, - 0x0440397a, 0xfe1b05ed, 0x0130da78, 0xff31a7c2, 0x008b80e7, 0xffa5b8c8, 0x00356a1c, 0xffe5964b, - 0x0007ab10, 0x000430ef, 0xfff57a65, 0x000cb50e, 0xfff3ec8c, 0x0009cd49, 0xfff5518a, 0xffffe482, - 0xfffb4624, 0xfffaabe7, 0x0008a30e, 0xfff0b084, 0x0017cfc6, 0xffde8f60, 0x002b1912, 0xffccc79b, - 0x0037be23, 0xffc9f8fa, 0x002a92bf, 0xffefde12, 0xffdcef04, 0x0087cf44, 0xfe7e3a7f, 0x08cc9a58, - 0x0440397a, 0xfe1b05ed, 0x0130da78, 0xff31a7c2, 0x008b80e7, 0xffa5b8c8, 0x00356a1c, 0xffe5964b, - 0x0007ab10, 0x000430ef, 0xfff57a65, 0x000cb50e, 0xfff3ec8c, 0x0009cd49, 0xfff5518a, -//Phase 2 - 0xfffa09d0, 0xfffccfb2, 0x000675ef, 0xfff2dfae, 0x001638f1, 0xffdea992, 0x002da9dc, 0xffc6181c, - 0x00443e9a, 0xffb5b905, 0x0048cad1, 0xffc4f01d, 0x0018889c, 0x00343b60, 0xfefb943a, 0x095affbe, - 0x03342865, 0xfe5cf355, 0x011ca417, 0xff328920, 0x00941355, 0xff98d1c6, 0x0043928a, 0xffd8167a, - 0x001361a9, 0xfffacec5, 0xfffc6c11, 0x0008012c, 0xfff6c7fb, 0x00083c34, 0xfff5737c, 0x00004ddd, - 0xfffa09d0, 0xfffccfb2, 0x000675ef, 0xfff2dfae, 0x001638f1, 0xffdea992, 0x002da9dc, 0xffc6181c, - 0x00443e9a, 0xffb5b905, 0x0048cad1, 0xffc4f01d, 0x0018889c, 0x00343b60, 0xfefb943a, 0x095affbe, - 0x03342865, 0xfe5cf355, 0x011ca417, 0xff328920, 0x00941355, 0xff98d1c6, 0x0043928a, 0xffd8167a, - 0x001361a9, 0xfffacec5, 0xfffc6c11, 0x0008012c, 0xfff6c7fb, 0x00083c34, 0xfff5737c, -//Phase 1 - 0xfff8d1c1, 0xffff26f1, 0x0003c35d, 0xfff5f74b, 0x0013397b, 0xffe0c1ef, 0x002da046, 0xffc28f99, - 0x004d3aba, 0xffa4ff99, 0x006415dc, 0xff9b4e21, 0x0056620c, 0xffd65b49, 0xff9c6f1a, 0x09bcd3e9, - 0x02300fed, 0xfeb03144, 0x00f9932c, 0xff3f1c18, 0x0093c335, 0xff9266da, 0x004d3f17, 0xffcd75dc, - 0x001d766c, 0xfff22933, 0x000338c9, 0x00031a3d, 0xfff9fe1d, 0x00064314, 0xfff5eb41, 0x00008746, - 0xfff8d1c1, 0xffff26f1, 0x0003c35d, 0xfff5f74b, 0x0013397b, 0xffe0c1ef, 0x002da046, 0xffc28f99, - 0x004d3aba, 0xffa4ff99, 0x006415dc, 0xff9b4e21, 0x0056620c, 0xffd65b49, 0xff9c6f1a, 0x09bcd3e9, - 0x02300fed, 0xfeb03144, 0x00f9932c, 0xff3f1c18, 0x0093c335, 0xff9266da, 0x004d3f17, 0xffcd75dc, - 0x001d766c, 0xfff22933, 0x000338c9, 0x00031a3d, 0xfff9fe1d, 0x00064314, 0xfff5eb41, -//Phase 0 - 0xfff7ad5a, 0x00019732, 0x0000acd2, 0xfff9d534, 0x000eeb91, 0xffe4d243, 0x002adce9, 0xffc2899a, - 0x0051ffd3, 0xff98f631, 0x007aae2f, 0xff7585cf, 0x0092f331, 0xff72c811, 0x005dec6f, 0x09eea069, - 0x013bb300, 0xff0ecd64, 0x00ca8e4e, 0xff560d09, 0x008affed, 0xff928c77, 0x005213df, 0xffc62fea, - 0x002568a8, 0xffeab5af, 0x00097f96, 0xfffe4a26, 0xfffd5b3f, 0x000400be, 0xfff6b054, 0x000581df, - 0xfff7ad5a, 0x00019732, 0x0000acd2, 0xfff9d534, 0x000eeb91, 0xffe4d243, 0x002adce9, 0xffc2899a, - 0x0051ffd3, 0xff98f631, 0x007aae2f, 0xff7585cf, 0x0092f331, 0xff72c811, 0x005dec6f, 0x09eea069, - 0x013bb300, 0xff0ecd64, 0x00ca8e4e, 0xff560d09, 0x008affed, 0xff928c77, 0x005213df, 0xffc62fea, - 0x002568a8, 0xffeab5af, 0x00097f96, 0xfffe4a26, 0xfffd5b3f, 0x000400be, 0xfff6b054, -}; -const int fir3_div_12_debug[384] = { - 180463, 17315, 9966, -3519, -23175, -48941, -80143, -115945, - -154862, -195352, -235295, -272723, -305110, -330335, -345666, -350011, - -341761, -319615, -283993, -235108, -174604, -104487, -27783, 52121, - 131167, 205194, 269850, 321188, 355645, 370443, 363456, 334230, - 283015, 211703, 123310, 22121, -86624, -196849, -302082, -395706, - -471475, -523755, -548026, -541115, -501694, -430121, -328794, -202086, - -56045, 101662, 262294, 416391, 554383, 667100, 746384, 785618, - 780259, 728184, 629949, 488904, 311243, 105572, -117239, -344781, - -563675, -760363, -921902, -1036796, -1095760, -1092407, -1023752, -890590, - -697640, -453478, -170141, 137335, 451724, 754562, 1027117, 1251607, - 1412233, 1496302, 1495075, 1404532, 1225812, 965430, 635092, 251272, - -165573, -592012, -1002986, -1373127, -1678386, -1897458, -2013235, -2014003, - -1894411, -1656082, -1307843, -865498, -351233, 207447, 779111, 1330136, - 1826577, 2236237, 2530653, 2686953, 2689519, 2531211, 2214213, 1750286, - 1160526, 474510, -271075, -1034326, -1770371, -2433917, -2981939, -3376359, - -3586500, -3591315, -3381021, -2958236, -2338365, -1549288, -630274, 369824, - 1395039, 2385256, 3279598, 4019991, 4554742, 4841882, 4852138, 4571251, - 4001539, 3162586, 2090910, 838675, -528631, -1935345, -3299567, -4537624, - -5568891, -6320628, -6732656, -6761503, -6383839, -5598887, -4429745, -2923330, - -1149054, 803918, 2830598, 4815256, 6637351, 8178070, 9327115, 9989436, - 10091478, 9586652, 8459649, 6729375, 4450210, 1711536, -1364571, -4627447, - -7903566, -11003742, -13731413, -15891721, -17300907, -17795614, -17241600, -15541471, - -12640960, -8533475, -3262579, 3077687, 10344832, 18352118, 26874930, 35658941, - 44429829, 52904066, 60800331, 67851008, 73813292, 78479327, 81684980, 83316788, - 83316788, 81684980, 78479327, 73813292, 67851008, 60800331, 52904066, 44429829, - 35658941, 26874930, 18352118, 10344832, 3077687, -3262579, -8533475, -12640960, - -15541471, -17241600, -17795614, -17300907, -15891721, -13731413, -11003742, -7903566, - -4627447, -1364571, 1711536, 4450210, 6729375, 8459649, 9586652, 10091478, - 9989436, 9327115, 8178070, 6637351, 4815256, 2830598, 803918, -1149054, - -2923330, -4429745, -5598887, -6383839, -6761503, -6732656, -6320628, -5568891, - -4537624, -3299567, -1935345, -528631, 838675, 2090910, 3162586, 4001539, - 4571251, 4852138, 4841882, 4554742, 4019991, 3279598, 2385256, 1395039, - 369824, -630274, -1549288, -2338365, -2958236, -3381021, -3591315, -3586500, - -3376359, -2981939, -2433917, -1770371, -1034326, -271075, 474510, 1160526, - 1750286, 2214213, 2531211, 2689519, 2686953, 2530653, 2236237, 1826577, - 1330136, 779111, 207447, -351233, -865498, -1307843, -1656082, -1894411, - -2014003, -2013235, -1897458, -1678386, -1373127, -1002986, -592012, -165573, - 251272, 635092, 965430, 1225812, 1404532, 1495075, 1496302, 1412233, - 1251607, 1027117, 754562, 451724, 137335, -170141, -453478, -697640, - -890590, -1023752, -1092407, -1095760, -1036796, -921902, -760363, -563675, - -344781, -117239, 105572, 311243, 488904, 629949, 728184, 780259, - 785618, 746384, 667100, 554383, 416391, 262294, 101662, -56045, - -202086, -328794, -430121, -501694, -541115, -548026, -523755, -471475, - -395706, -302082, -196849, -86624, 22121, 123310, 211703, 283015, - 334230, 363456, 370443, 355645, 321188, 269850, 205194, 131167, - 52121, -27783, -104487, -174604, -235108, -283993, -319615, -341761, - -350011, -345666, -330335, -305110, -272723, -235295, -195352, -154862, - -115945, -80143, -48941, -23175, -3519, 9966, 17315, 180463, - }; diff --git a/lib_mic_array/src/fir/fir_coefs_dual.xc b/lib_mic_array/src/fir/fir_coefs_dual.xc deleted file mode 100644 index aba86a13..00000000 --- a/lib_mic_array/src/fir/fir_coefs_dual.xc +++ /dev/null @@ -1,18 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -// Autogenerated by make_mic_dual_stage_3_coeffs.c - -const int [[aligned(8)]] g_third_stage_div_6_fir_dual[192] = { -// Phase 5 -0x00056b0b, 0xffec4271, 0x000ab85d, 0xfff7114f, 0x0001ac8b, 0x000c872a, 0xffdcd208, 0x00434fce, 0xff92a99c, 0x00a103b7, 0xff226ab2, 0x01223a34, 0xfe90bfd9, 0x01c962c9, 0xfdb96f67, 0x036bfaa7, 0x13cf57fd, 0xfff38db5, 0xff482b9c, 0x00ec0041, 0xff0dc9ac, 0x00e1a4a1, 0xff3b830c, 0x00a12152, 0xff83c10b, 0x005954d9, 0xffc5293c, 0x0022402d, 0xffefdfa2, 0x00044ec3, 0x0001234a, 0xfff00920, -// Phase 4 -0xffff9433, 0xffea8d5f, 0x001279c0, 0xffea56a3, 0x00152924, 0xfff16cd0, 0xffff5ddf, 0x001af2fc, 0xffbd4f63, 0x007a0de7, 0xff3c8068, 0x0122e2c6, 0xfe5f4847, 0x02547782, 0xfc6e3736, 0x077d3344, 0x1248152e, 0xfd6e5ae1, 0x00bf2a27, 0xfff54c43, 0xffb3a3be, 0x007519a2, 0xff7dd845, 0x007dadc7, 0xff917c11, 0x0059cafc, 0xffbc8e55, 0x002e6234, 0xffe36edb, 0x000f24c4, 0xfff7c2dd, 0xfff4cafd, -// Phase 3 -0xfffd39ae, 0xffebc62f, 0x0016852f, 0xffe14178, 0x0025cee3, 0xffd6e958, 0x00258eaa, 0xffe835e9, 0xfffc0293, 0x003208ec, 0xff885579, 0x00dcfeab, 0xfe8dff27, 0x025fd820, 0xfbc44ffe, 0x0bac480b, 0x0f704c5a, 0xfc0a2dd4, 0x01d58c4e, 0xff1cf28c, 0x005a2d0b, 0xfff86104, 0xffd73fd0, 0x004182ab, 0xffb65924, 0x004687a0, 0xffc37859, 0x002f40e6, 0xffde7937, 0x001584ad, 0xfff04854, 0xfff976f5, -// Phase 2 -0xfff976f5, 0xfff04854, 0x001584ad, 0xffde7937, 0x002f40e6, 0xffc37859, 0x004687a0, 0xffb65924, 0x004182ab, 0xffd73fd0, 0xfff86104, 0x005a2d0b, 0xff1cf28c, 0x01d58c4e, 0xfc0a2dd4, 0x0f704c5a, 0x0bac480b, 0xfbc44ffe, 0x025fd820, 0xfe8dff27, 0x00dcfeab, 0xff885579, 0x003208ec, 0xfffc0293, 0xffe835e9, 0x00258eaa, 0xffd6e958, 0x0025cee3, 0xffe14178, 0x0016852f, 0xffebc62f, 0xfffd39ae, -// Phase 1 -0xfff4cafd, 0xfff7c2dd, 0x000f24c4, 0xffe36edb, 0x002e6234, 0xffbc8e55, 0x0059cafc, 0xff917c11, 0x007dadc7, 0xff7dd845, 0x007519a2, 0xffb3a3be, 0xfff54c43, 0x00bf2a27, 0xfd6e5ae1, 0x1248152e, 0x077d3344, 0xfc6e3736, 0x02547782, 0xfe5f4847, 0x0122e2c6, 0xff3c8068, 0x007a0de7, 0xffbd4f63, 0x001af2fc, 0xffff5ddf, 0xfff16cd0, 0x00152924, 0xffea56a3, 0x001279c0, 0xffea8d5f, 0xffff9433, -// Phase 0 -0xfff00920, 0x0001234a, 0x00044ec3, 0xffefdfa2, 0x0022402d, 0xffc5293c, 0x005954d9, 0xff83c10b, 0x00a12152, 0xff3b830c, 0x00e1a4a1, 0xff0dc9ac, 0x00ec0041, 0xff482b9c, 0xfff38db5, 0x13cf57fd, 0x036bfaa7, 0xfdb96f67, 0x01c962c9, 0xfe90bfd9, 0x01223a34, 0xff226ab2, 0x00a103b7, 0xff92a99c, 0x00434fce, 0xffdcd208, 0x000c872a, 0x0001ac8b, 0xfff7114f, 0x000ab85d, 0xffec4271, 0x00056b0b, -}; diff --git a/lib_mic_array/src/fir/fir_design.py b/lib_mic_array/src/fir/fir_design.py deleted file mode 100755 index 6d6df867..00000000 --- a/lib_mic_array/src/fir/fir_design.py +++ /dev/null @@ -1,529 +0,0 @@ -#!/usr/bin/env python -# Copyright 2016-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. - -import argparse -import numpy -import scipy -import ctypes -import matplotlib -import sys -import math -import datetime -from scipy import signal -import numpy as np -import matplotlib.pyplot as plt - -int32_max = np.int64(np.iinfo(np.int32).max) -int64_max = np.int64(np.iinfo(np.int64).max) - -############################################################################### - -def parseArguments(third_stage_configs): - parser = argparse.ArgumentParser(description="Filter builder") - - #this must be set for all other bandwidths to be relative to - parser.add_argument('--pdm-sample-rate', type=float, default=3072.0, - help='The sample rate (in kHz) of the PDM microphones', - metavar='kHz') - - parser.add_argument('--use-low-ripple-first-stage', type=bool, default=False, - help='Use the lowest ripple possible for the given output passband.') - - parser.add_argument('--first-stage-num-taps', type=int, default=48, - help='The number of FIR taps in the first stage of decimation.') - parser.add_argument('--first-stage-pass-bw', type=float, default = 20.0, - help='The pass bandwidth (in kHz) of the first stage filter.' - ' Starts at 0Hz and ends at this frequency', metavar='kHz') - parser.add_argument('--first-stage-stop-bw', type=float, default = 24.0, - help='The stop bandwidth (in kHz) of the first stage filter.', - metavar='kHz') - parser.add_argument('--first-stage-stop-atten', type=float, default = -120.0, - help='The stop band attenuation(in dB) of the first stage filter(Normally negative).', metavar='dB') - - parser.add_argument('--second-stage-pass-bw', type=float, default=16, - help='The number of FIR taps per stage ' - ' Starts at 0Hz and ends at this frequency', metavar='kHz') - parser.add_argument('--second-stage-stop-bw', type=float, default=16, - help='The number of FIR taps per stage ' - ' Starts at 0Hz and ends at this frequency', metavar='kHz') - parser.add_argument('--second-stage-stop-atten', type=float, default = -70.0, - help='The stop band attenuation(in dB) of the second stage filter(Normally negative).', metavar='dB') - - parser.add_argument('--third-stage-num-taps', type=int, default=32, - help='The number of FIR taps per stage ' - '(decimation factor). The fewer there are the lower the group delay.') - - parser.add_argument('--third-stage-stop-atten', type=float, default = -70.0, - help='The stop band attenuation(in dB) of the third stage filter(Normally negative).', metavar='dB') - - parser.add_argument('--add-third-stage', nargs=5, - help='Add a custom third stage filter; e.g. 6 6.2 8.1 custom_16k_filt 32', - metavar=('DIVIDER', 'PASS_BANDWIDTH', 'STOP_BAND_START', 'NAME', 'NUM_TAPS')) - - args = parser.parse_args() - - to_add = args.add_third_stage - if to_add: - pdm_rate = float(args.pdm_sample_rate) - print "****** Input rate for custom filter: " + str(args.pdm_sample_rate) + "kHz. ********" - try: - divider = int(to_add[0]) - passbw = float(to_add[1]) - stopbw = float(to_add[2]) - name = str(to_add[3]) - num_taps = int(to_add[4]) - norm_pass = passbw / (pdm_rate/8/4 / divider) - norm_stop = stopbw / (pdm_rate/8/4 / divider) - third_stage_configs.append( - [divider, norm_pass, norm_stop, name, num_taps, True]) - except: - print("ERROR: Invalid arguments for third stage") - sys.exit(1) - - return args - -############################################################################### - -def measure_stopband_and_ripple(bands, a, H): - - passband_max = float('-inf'); - passband_min = float('inf'); - stopband_max = float('-inf'); - - # freq = 0.5*np.arange(len(h))/len(h) - # mag = 20.0*np.log10(H) - - #The bands are evenly spaced throughout 0 to 0.5 of the bandwidth - for h in range(0, H.size): - freq = 0.5*h/(H.size) - mag = 20.0 * numpy.log10(abs(H[h])) - for r in range(0, len(bands), 2): - if freq > bands[r] and freq < bands[r+1]: - if a[r/2] == 0: - stopband_max = max(stopband_max, mag) - else: - passband_max = max(passband_max, mag) - passband_min = min(passband_min, mag) - - return [stopband_max, passband_max, passband_min] - -############################################################################### - -def plot_response(H, file_name): - magnitude_response = 20 * numpy.log10(abs(H)) - input_freq = numpy.arange(0.0, 0.5, 0.5/len(magnitude_response)) - plt.clf() - plt.plot(input_freq, magnitude_response) - plt.ylabel('Magnitude Response') - plt.xlabel('Normalised Input Freq') - plt.savefig(file_name +'.pdf', format='pdf', dpi=1000) - -############################################################################### - - -def generate_stage(num_taps, bands, a, weights, divider=1, num_frequency_points=2048, stopband_attenuation = -65.0): - - w = np.ones(len(a)) - - weight_min = 0.0 - weight_max = 1024.0 - - running = True - - epsilon = 0.0000000001 - - while running: - test_weight = (weight_min + weight_max)/2.0 - for i in range(0, len(a)-1): - if a[i] != 0: - w[i] = test_weight*weights[i] - # w = weights*test_weight*(a!= 0.0) - - try: - h = signal.remez(num_taps, bands, a, w) - - (_, H) = signal.freqz(h, worN=2048) - - [stop_band_atten, passband_min, passband_max ] = measure_stopband_and_ripple(bands, a, H) - - if (-stop_band_atten) > -stopband_attenuation: - weight_min = test_weight - else: - weight_max = test_weight - - #print str(stop_band_atten) + ' ' + str(passband_max) + ' ' + str(passband_min) + ' ' +str(test_weight) - if abs(weight_min - weight_max) < epsilon: - running=False - except ValueError: - if abs(test_weight - weight_max) < epsilon: - print "Failed to converge - unable to create filter" - return - else: - weight_min = test_weight - - (_, H) = signal.freqz(h, worN=num_frequency_points) - - return H, h - -############################################################################### - -def generate_first_stage(header, body, points, pbw, sbw, first_stage_num_taps, first_stage_stop_atten): - nulls = 1.0/8.0 - a = np.zeros(2) - a[0] = 1.0 - w = np.ones(len(a)) - - bands = [ 0, pbw, nulls-sbw, 0.5] - - return first_stage_output_coefficients(header, body, points, first_stage_num_taps, first_stage_stop_atten, nulls, a, w, bands) - -def generate_first_stage_low_ripple(header, body, points, pbw, sbw, first_stage_num_taps, first_stage_stop_atten): - - nulls = 1.0/8.0 - a = np.zeros(5) - a[0] = 1.0 - w = np.ones(len(a)) - bands = [ 0, pbw, - nulls*1-sbw, nulls*1+sbw, - nulls*2-sbw, nulls*2+sbw, - nulls*3-sbw, nulls*3+sbw, - nulls*4-sbw, 0.5] - - return first_stage_output_coefficients(header, body, points, first_stage_num_taps, first_stage_stop_atten, nulls, a, w, bands) - -def first_stage_output_coefficients(header, body, points, first_stage_num_taps, first_stage_stop_atten, nulls, a, w, bands): - - first_stage_response, coefs = generate_stage( - first_stage_num_taps, bands, a, w, stopband_attenuation = first_stage_stop_atten) - - #ensure the there is never any overflow - coefs /= sum(abs(coefs)) - - total_abs_sum = 0 - for t in range(0, len(coefs)/(8*2)): - header.write("extern const int g_first_stage_fir_"+str(t)+"[256];\n") - body.write("const int g_first_stage_fir_"+str(t)+"[256] = {\n\t") - max_for_block = np.int64(0) - for x in range(0, 256): - d=0.0 - for b in range(0, 8): - if(((x>>(7-b))&1) == 1) : - d = d + coefs[t*8 + b] - else: - d = d - coefs[t*8 + b] - d_int = np.int32(d*np.float64(int32_max)) - max_for_block = max(max_for_block, np.abs(np.int64(d_int))) - body.write("0x{:08x}, ".format(ctypes.c_uint(d_int).value)) - if (x&7)==7: - body.write("\n\t") - body.write("};\n\n") - total_abs_sum += (max_for_block*2) - - if total_abs_sum > int32_max: - print "WARNING: error in first stage too large" - else: - print "Max output of firzst stage: " + str(total_abs_sum) - - body.write("const int fir1_debug[" + str(first_stage_num_taps) + "] = {\n\n") - header.write("extern const int fir1_debug[" + str(first_stage_num_taps) + "];\n") - for i in range(0, len(coefs)): - body.write("{:10d}, ".format(int(float(int32_max)*coefs[i]))) - if((i&7)==7): - body.write("\n") - body.write("};\n") - - (_, H) = signal.freqz(coefs, worN=points) - plot_response(H, 'first_stage') - [stop, passband_min, passband_max] = measure_stopband_and_ripple(bands, a, H) - max_passband_output = int(float(int32_max) * 10.0 ** (passband_max/20.0) + 1) - header.write("#define FIRST_STAGE_MAX_PASSBAND_OUTPUT (" + str(max_passband_output) +")\n") - header.write("\n") - - return H - - -############################################################################### - -def generate_second_stage(header, body, points, pbw, sbw, second_stage_num_taps, stop_band_atten): - - nulls = 1.0/4.0 - a = [1, 0, 0] - w = [1, 1, 1] - - bands = [ 0, pbw, - nulls*1-sbw, nulls*1+sbw, - nulls*2-sbw, 0.5] - - second_stage_response, coefs = generate_stage( - second_stage_num_taps, bands, a, w, stopband_attenuation = stop_band_atten) - - - #ensure the there is never any overflow - coefs /= sum(abs(coefs)) - - header.write("extern const int g_second_stage_fir[8];\n") - body.write("const int g_second_stage_fir[8] = {\n") - - total_abs_sum = np.int64(0) - for i in range(0, len(coefs)/2): - if coefs[i] > 0.5: - print "Single coefficient too big in second stage FIR" - d_int = np.int32(coefs[i]*float(int32_max)*2.0); - total_abs_sum += np.abs(np.int64(d_int)*2) - body.write("\t0x{:08x},\n".format(ctypes.c_uint(d_int).value)) - body.write("};\n\n") - - if total_abs_sum*int32_max > int64_max: - print "WARNING: error in second stage too large" - - - body.write("const int fir2_debug[" + str(second_stage_num_taps) + "] = {\n") - header.write("extern const int fir2_debug[" + str(second_stage_num_taps) + "];\n\n") - for i in range(0, len(coefs)): - body.write("{:10d}, ".format(int(float(int32_max)*coefs[i]))) - if((i&7)==7): - body.write("\n") - body.write("};\n\n") - - (_, H) = signal.freqz(coefs, worN=points) # this is where the ripple is derived from - plot_response(H, 'second_stage') - - [stop, passband_min, passband_max] = measure_stopband_and_ripple(bands, a, H) - - # plt.clf() - # plt.plot(np.log10(np.abs(H))*20.) - # plt.show() - return H - -############################################################################### - -def generate_third_stage(header, body, third_stage_configs, combined_response, points, input_sample_rate, stop_band_atten): - - max_coefs_per_phase = 32 - - for config in third_stage_configs: - divider = config[0] - passband = config[1] - stopband = config[2] - name = config[3] - coefs_per_phase = config[4] - - #if is_custom then use the PDM rate for making the graphs - is_custom = config[5] - - pbw = passband/divider - sbw = stopband/divider - - a = [1, 0] - w = [1, 1] - - bands = [0, pbw, sbw, 0.5] - - third_stage_response, coefs = generate_stage( - coefs_per_phase*divider, bands, a, w, stopband_attenuation = stop_band_atten) - - #ensure the there is never any overflow - coefs /= sum(abs(coefs)) - - body.write("const int g_third_stage_" +name+ "_fir["+str(divider*(2*max_coefs_per_phase - 1))+ "] = {\n"); - header.write("extern const int g_third_stage_" +name+ "_fir["+str(divider*(2*max_coefs_per_phase - 1))+ "];\n"); - - total_abs_sum = 0 - for phase in reversed(range(divider)): - body.write("//Phase " + str(phase)+"\n\t") - for i in range(coefs_per_phase): - index = coefs_per_phase*divider - divider - (i*divider - phase); - if coefs[i] > 0.5: - print "Single coefficient too big in third stage FIR" - d_int = np.int32(coefs[index]*float(int32_max)*2.0); - total_abs_sum += np.abs(np.int64(d_int)) - body.write("0x{:08x}, ".format(ctypes.c_uint(d_int).value)) - if (i%8)==7: - body.write("\n\t"); - for i in range(coefs_per_phase, max_coefs_per_phase): - body.write("0x{:08x}, ".format(ctypes.c_uint(0).value)) - if (i%8)==7: - body.write("\n\t"); - - for i in range(coefs_per_phase-1): - index = coefs_per_phase*divider - divider - (i*divider - phase); - d_int = int(coefs[index]*float(int32_max)*2.0); - body.write("0x{:08x}, ".format(ctypes.c_uint(d_int).value)) - if (i%8)==7: - body.write("\n\t"); - for i in range(coefs_per_phase-1, max_coefs_per_phase-1): - body.write("0x{:08x}, ".format(ctypes.c_uint(0).value)) - if (i%8)==7: - body.write("\n\t"); - - body.write("\n"); - - body.write("};\n"); - - max_macc = total_abs_sum*int32_max - if total_abs_sum*int32_max > int64_max: - print "WARNING: error in third stage too large" - - body.write("const int fir3_"+ name+"_debug[" + str(max_coefs_per_phase*divider)+ "] = {\n\t"); - header.write("extern const int fir3_"+ name+"_debug[" + str(max_coefs_per_phase*divider) + "];\n"); - - for i in range(coefs_per_phase*divider): - body.write("{:10d}, ".format(int(float(int32_max)*coefs[i]))) - if (i%8)==7: - body.write("\n\t"); - - for i in range(coefs_per_phase*divider, max_coefs_per_phase*divider): - body.write("{:10d}, ".format(int(0))) - if (i%8)==7: - body.write("\n\t"); - - body.write("};\n"); - - (_, H) = signal.freqz(coefs, worN=points) - - plot_response(H, 'third_stage_' + str(name)) - - passband_max = float('-inf'); - passband_min = float('inf'); - - magnitude_response = [] - input_freq = [] - - for i in range(points): - mag = combined_response[i] * abs(H[i]) - freq = 0.5*i/points - if freq < 0.5/divider: - magnitude_response.append(mag) - if is_custom: - input_freq.append(freq*input_sample_rate) - else: - input_freq.append(freq*divider) - if freq < passband/divider: - passband_max = max(passband_max, mag) - passband_min = min(passband_min, mag) - - magnitude_response /= passband_max - magnitude_response = 20*numpy.log10(magnitude_response) - plt.clf() - plt.plot(input_freq, magnitude_response) - plt.ylabel('Magnitude Response') - if is_custom: - plt.xlabel('Frequency (kHz)') - else: - plt.xlabel('Normalised Output Freq') - plt.savefig("output_" + name +'.pdf', format='pdf', dpi=1000) - - print "Filter name: " + name - print "Final stage divider: " + str(divider) - print "Output sample rate: " + str(input_sample_rate/divider)+ "kHz" - print "Pass bandwidth: " + str(input_sample_rate*passband/divider) + "kHz of " + str(input_sample_rate/(divider*2)) + "kHz total bandwidth." - print "Pass bandwidth(normalised): " + str(passband*2) + " of Nyquist." - print "Stop band start: " + str(input_sample_rate*stopband/divider) + "kHz of " + str(input_sample_rate/(divider*2)) + "kHz total bandwidth." - print "Stop band start(normalised): " + str(stopband*2) + " of Nyquist." - print "Stop band attenuation: " + str(stop_band_atten)+ "dB." - - # print "(3.072MHz) Passband:" + str(48000*2*passband/divider) + "Hz Stopband:"+ str(48000*2*stopband/divider) + "Hz" - # print "(2.822MHz) Passband:" + str(44100*2*passband/divider) + "Hz Stopband:"+ str(44100*2*stopband/divider) + "Hz" - - if 1.0/passband_max > 8.0: - print "Error: Compensation factor is too large" - - #The compensation factor should be in Q(5.27) format - comp_factor = ((1<<27) - 1)/passband_max - - header.write("#define FIR_COMPENSATOR_" + name.upper() + " (" + str(int(comp_factor)) +")\n") - - header.write("\n") - print "Passband ripple = " + str(abs(20.0*numpy.log10(passband_min/passband_max))) +" dB\n" - return - -############################################################################### - -if __name__ == "__main__": - # Each entry generates a output - third_stage_configs = [ - #divider, normalised pb, normalised sb, name, taps per phase, is_custom - [2, 0.38, 0.50, "div_2", 32, False], - [4, 0.42, 0.52, "div_4", 32, False], - [6, 0.42, 0.52, "div_6", 32, False], - [8, 0.42, 0.52, "div_8", 32, False], - [12, 0.42, 0.52, "div_12", 32, False] - ] - args = parseArguments(third_stage_configs) - - input_sample_rate = args.pdm_sample_rate - input_band_width = input_sample_rate/2.0 - first_stage_pbw = args.first_stage_pass_bw/args.pdm_sample_rate - first_stage_sbw = args.first_stage_stop_bw/args.pdm_sample_rate - first_stage_num_taps = int(args.first_stage_num_taps) - first_stage_stop_band_atten = args.first_stage_stop_atten - first_stage_low_ripple = args.use_low_ripple_first_stage - -#warnings - if first_stage_stop_band_atten > 0: - print "Warning first stage stop band attenuation is positive." - - print "Filer Configuration:" - print "Input(PDM) sample rate: " + str(input_sample_rate) + "kHz" - print "First Stage" - print "Num taps: " + str(first_stage_num_taps) - print "Pass bandwidth: " + str(args.first_stage_pass_bw) + "kHz of " + str(input_band_width) + "kHz total bandwidth." - print "Pass bandwidth(normalised): " + str(first_stage_pbw*2) + " of Nyquist." - print "Stop band attenuation: " + str(first_stage_stop_band_atten)+ "dB." - print "Stop bandwidth: " + str(args.first_stage_stop_bw) + "kHz" - print "Lowest Ripple: " + str(first_stage_low_ripple) - - - header = open ("fir_coefs.h", 'w') - body = open ("fir_coefs.xc", 'w') - - year = datetime.datetime.now().year - header.write("// Copyright (c) " +str(year) +", XMOS Ltd, All rights reserved\n") - body.write("// Copyright (c) " +str(year) +", XMOS Ltd, All rights reserved\n") - - points = 8192*8 - combined_response = [] - - if first_stage_low_ripple: - first_stage_response = generate_first_stage_low_ripple(header, body, points, first_stage_pbw, first_stage_sbw, first_stage_num_taps, first_stage_stop_band_atten) - else: - first_stage_response = generate_first_stage(header, body, points, first_stage_pbw, first_stage_sbw, first_stage_num_taps, first_stage_stop_band_atten) - #Save the response between 0 and 48kHz - for r in range(0, points/(8*4)+1): - combined_response.append(abs(first_stage_response[r])) - - second_stage_num_taps = 16 - second_stage_pbw = args.second_stage_pass_bw/(input_sample_rate/8.0) - second_stage_sbw = args.second_stage_stop_bw/(input_sample_rate/8.0) - second_stage_stop_band_atten = args.second_stage_stop_atten - - print "" -#warnings - if second_stage_stop_band_atten > 0: - print "Warning second stage stop band attenuation is positive." - - print "Second Stage" - print "Num taps: " + str(second_stage_num_taps) - print "Pass bandwidth: " + str(args.second_stage_pass_bw) + "kHz of " + str(input_sample_rate/8.0) + "kHz total bandwidth." - print "Pass bandwidth(normalised): " + str(second_stage_pbw*2) + " of Nyquist." - print "Stop band attenuation: " + str(second_stage_stop_band_atten)+ "dB." - print "Stop bandwidth: " + str(args.second_stage_stop_bw) + "kHz" - - second_stage_response = generate_second_stage(header, body, points/8, second_stage_pbw, second_stage_sbw, second_stage_num_taps, second_stage_stop_band_atten) - for r in range(0, points/(8*4)): - combined_response[r] = combined_response[r] * abs(second_stage_response[r]) - - third_stage_stop_band_atten = args.third_stage_stop_atten - print "" -#warnings - if third_stage_stop_band_atten > 0: - print "Warning third stage stop band attenuation is positive." - - print "Third Stage" - generate_third_stage(header, body, third_stage_configs, combined_response, points/(8*4), input_sample_rate/8.0/4.0, third_stage_stop_band_atten) - - header.write("#define THIRD_STAGE_COEFS_PER_STAGE (32)\n") - - - diff --git a/lib_mic_array/src/fir/make_mic_dual_stage_3_coefs.c b/lib_mic_array/src/fir/make_mic_dual_stage_3_coefs.c deleted file mode 100644 index 1ab678bf..00000000 --- a/lib_mic_array/src/fir/make_mic_dual_stage_3_coefs.c +++ /dev/null @@ -1,87 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. - -//This program takes the coeffs for normal mic_array and generates a version for mic_dual -//It removes the repetition which mic_dual inner loop doesn't need and 8-byte aligns them so we can use stdd/ldd. -//Bonus: we also save just over 1kB of memory.. - -//To make this do: -// cp fir_coefs.xc fir_coefs.c; cc make_mic_dual_stage_3_coefs.c fir_coefs.c; rm fir_coefs.c; ./a.out - -#include -#include -#include -#include -#include "fir_coefs.h" //From lib_mic_array to access const int g_third_stage_div_6_fir[378] - -#define NUM_PHASES 6 -#define NUM_TAPS 32 - -int main(void){ - int * phase_coeff_ptrs[NUM_PHASES]; - - int final_stage_coeffs_copy[3][32]; - - //Copy non 8 byte aligned coefficients and setup nice array of pointers for each phase of coefficients - const size_t phase_coeff_size = (NUM_TAPS * sizeof(int)); - int * g_third_stage_div_6_fir_ptr = (int * )g_third_stage_div_6_fir; - phase_coeff_ptrs[0] = (int * )&g_third_stage_div_6_fir_ptr[0 * 63]; - memcpy(&final_stage_coeffs_copy[0], &g_third_stage_div_6_fir_ptr[1 * 63], phase_coeff_size); - phase_coeff_ptrs[1] = (int * )&final_stage_coeffs_copy[0]; - phase_coeff_ptrs[2] = (int * )&g_third_stage_div_6_fir_ptr[2 * 63]; - memcpy(&final_stage_coeffs_copy[1], &g_third_stage_div_6_fir_ptr[3 * 63], phase_coeff_size); - phase_coeff_ptrs[3] = (int * )&final_stage_coeffs_copy[1]; - phase_coeff_ptrs[4] = (int * )&g_third_stage_div_6_fir_ptr[4 * 63]; - memcpy(&final_stage_coeffs_copy[2], &g_third_stage_div_6_fir_ptr[5 * 63], phase_coeff_size); - phase_coeff_ptrs[5] = (int * )&final_stage_coeffs_copy[2]; - // //for (int i=0; i<6; i++) printf("ptr %d: 0x%p\n", i, phase_coeff_ptrs[i]); - - char array_text[65536] = {0}; //Should only need around 3kB or so but we have loads.. - char tmp[1024]; - - time_t timer; - struct tm* tm_info; - time(&timer); - tm_info = localtime(&timer); - char year[5]; - strftime(year, 5, "%Y", tm_info); - char copyright_string[52] = { - 47, 47, 32, 67, 111, 112, 121, 114, 105, 103, 104, 116, 32, 40, 99, 41, 32, - 37, 115, 44, 32, 88, 77, 79, 83, 32, 76, 116, 100, 44, 32, 65, 108, 108, 32, - 114, 105, 103, 104, 116, 115, 32, 114, 101, 115, 101, 114, 118, 101, 100, 10, - 0 - }; - sprintf(tmp, copyright_string, year); - strcat(array_text, tmp); - strcat(array_text, "// Autogenerated by make_mic_dual_stage_3_coeffs.c\n\n"); - - sprintf(tmp, "const int [[aligned(8)]] g_third_stage_div_6_fir_dual[%d] = {\n", NUM_TAPS * NUM_PHASES); - - strcat(array_text, tmp); - for(int ph=NUM_PHASES-1;ph>=0;ph--){ - sprintf(tmp, "// Phase %d\n", ph); - strcat(array_text, tmp); - for(int i=0;i +#include +#include + +#include "mic_array/frame_transfer.h" + + +void ma_frame_tx( + const chanend_t c_frame_out, + const int32_t frame[], + const unsigned channel_count, + const unsigned sample_count) +{ + transacting_chanend_t ct_frame = chan_init_transaction_master(c_frame_out); + t_chan_out_buf_word(&ct_frame, + (uint32_t*) frame, + channel_count * sample_count); + chan_complete_transaction(ct_frame); +} + + + + +void ma_frame_rx( + int32_t frame[], + const chanend_t c_frame_in, + const unsigned channel_count, + const unsigned sample_count) +{ + transacting_chanend_t ct_frame = chan_init_transaction_slave(c_frame_in); + t_chan_in_buf_word(&ct_frame, + (uint32_t*) frame, + channel_count * sample_count); + chan_complete_transaction(ct_frame); +} + + +void ma_frame_rx_transpose( + int32_t frame[], + const chanend_t c_frame_in, + const unsigned channel_count, + const unsigned sample_count) +{ + transacting_chanend_t ct_frame = chan_init_transaction_slave(c_frame_in); + for(int ch = 0; ch < channel_count; ch++){ + for(int smp = 0; smp < sample_count; smp++){ + frame[smp*channel_count+ch] = t_chan_in_word(&ct_frame); + } + } + chan_complete_transaction(ct_frame); +} diff --git a/lib_mic_array/src/hires_delay.xc b/lib_mic_array/src/hires_delay.xc deleted file mode 100644 index 48749897..00000000 --- a/lib_mic_array/src/hires_delay.xc +++ /dev/null @@ -1,73 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include - -#include "mic_array.h" -#include - -unsigned g_hires_shared_memory[16]; - -#define MICS_PER_S_CHAN 4 - -#pragma unsafe arrays -void mic_array_hires_delay( - streaming chanend c_from_pdm_frontend[], - streaming chanend c_to_decimator[], - unsigned n, - streaming chanend c_cmd){ - - unsigned delays[16] = {0}; - int data[16][MIC_ARRAY_HIRES_MAX_DELAY]; - memset(data, 0, sizeof(int)*16*MIC_ARRAY_HIRES_MAX_DELAY); - - unsigned head = 0; - while(1){ - for(unsigned i=0;i data[i+j*MICS_PER_S_CHAN][head]; - } - } - - for(unsigned i=0;i unsigned n :{ - for(unsigned i=0;i -#include -#include -#include -#include -#include -#include "mic_array.h" //FRAME SIZE and coeffs -extern const int [[aligned(8)]] g_third_stage_div_6_fir_dual[192]; //From fir_coefs_dual.xc. We make a LL aligned copy of this -#include "dsp_qformat.h" //Gain compensation - -#if (defined(MIC_DUAL_ENABLED) && (MIC_DUAL_ENABLED == 0)) -#undef MIC_DUAL_ENABLED -#endif - -#ifndef MIC_DUAL_ENABLED - #ifdef MIC_DUAL_FRAME_SIZE - #error "Set MIC_DUAL_ENABLED to 1." - #endif -#endif - -#define MIC_DUAL_OUTPUT_BLOCK_SIZE MIC_DUAL_FRAME_SIZE -#define MIC_DUAL_GAIN_COMPENSATION 2.117307f //Value needed to bring mic level up to inputNear[] compared with lib_mic_array - //Max is 7.999 due to Q28 format -#ifndef MIC_DUAL_NUM_OUT_BUFFERS - #define MIC_DUAL_NUM_OUT_BUFFERS 2 //Single (1) or double (2) buffered -#endif -#define MIC_DUAL_NUM_CHANNELS 2 //Always 2 because it's a pair of mics we are decimating -#define MIC_DUAL_NUM_REF_CHANNELS 2 //Always 2 in xvf3510 case - - -#pragma unsafe arrays -//This effectively implements a delayline of 6 chars of bits, the later three reversed -static inline int first_stage_fir(unsigned char pdm, unsigned delay_line[]){ - - //Move delay line along one byte (8 x 1b samples) and insert 8 pdm bits at bottom - //Top (oldest) byte is not directly used but instead reversed and copied by next stage - delay_line[0] <<= 8; - delay_line[0] |= pdm; - - //Oldest 8b pops into top, bitrev it and add to the second, reverse part of delay line - //We do not use the MSB of this word - unsigned tmp = bitrev(delay_line[0]); - tmp &= 0xff; - delay_line[1] <<= 8; - delay_line[1] |= tmp; - - //Do the 6 (* 8) dot products and accumulate - int accumulator = 0; - unsigned char * delayline_ptr = (unsigned char *)&delay_line; - accumulator += g_first_stage_fir_0[*(delayline_ptr + 0)]; - accumulator += g_first_stage_fir_0[*(delayline_ptr + 6)]; - accumulator += g_first_stage_fir_1[*(delayline_ptr + 1)]; - accumulator += g_first_stage_fir_1[*(delayline_ptr + 5)]; - accumulator += g_first_stage_fir_2[*(delayline_ptr + 2)]; - accumulator += g_first_stage_fir_2[*(delayline_ptr + 4)]; - - return accumulator; -} - - -//16 tap FIR for middle stage (384kHz -> 96kHz) -#pragma unsafe arrays -static inline int mid_stage_fir(const int mid_stage_fir[], int mid_stage_delay[], unsigned mid_stage_delay_idx){ - unsafe{ - int ah = 0; - unsigned al = 0; - int c0, c1, s0, s1; - - int * unsafe filter_ptr = (int*)mid_stage_fir; - int * unsafe state_ptr = &mid_stage_delay[mid_stage_delay_idx]; - - unsigned format = 32; //for extract - //Note because FIR is symmetrical, we only need load the first half of the coeffs - //and we do not need to reload them into registers, so it's very fast (2.5 cyc per MAC) - - //stages 0, 1, 14, 15 - asm volatile("ldd %0,%1,%2[0]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm volatile("ldd %0,%1,%2[0]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm volatile("ldd %0,%1,%2[7]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s1),"0"(ah),"1"(al)); - - - //stages 2, 3, 12, 13 - asm volatile("ldd %0,%1,%2[1]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm volatile("ldd %0,%1,%2[1]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm volatile("ldd %0,%1,%2[6]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s1),"0"(ah),"1"(al)); - - - //stages 4, 5, 10, 11 - asm volatile("ldd %0,%1,%2[2]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm volatile("ldd %0,%1,%2[2]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm volatile("ldd %0,%1,%2[5]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s1),"0"(ah),"1"(al)); - - - //stages 6, 7, 8, 9 - asm volatile("ldd %0,%1,%2[3]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm volatile("ldd %0,%1,%2[3]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm volatile("ldd %0,%1,%2[4]":"=r"(s0),"=r"(s1):"r"(state_ptr)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s0),"0"(ah),"1"(al)); - asm volatile("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s1),"0"(ah),"1"(al)); - - - //extract and saturate - asm volatile("lsats %0,%1,%2":"=r"(ah),"=r"(al):"r"(format),"0"(ah),"1"(al)); - asm volatile("lextract %0,%1,%2,%3,32":"=r"(ah):"r"(ah),"r"(al),"r"(format)); - - return ah; - } -} - - -//POLY FIR 192 Taps by 6 = 32 taps per stage -//Note this expects the coeffs in reverse order -#pragma unsafe arrays -unsafe static inline int final_stage_poly_fir( - int input_sample, - int delayline[], - int * unsafe filter_ptr) -{ - - int ah = 0; - unsigned al = 0; - int c0, c1, s0 = input_sample, s1, s2, s3; - - - int * unsafe state_ptr; - unsafe{ - state_ptr = (int * unsafe)delayline; - //printf("state: 0x%x filter: 0x%x\n", state_ptr, filter_ptr); - } - - unsigned format = 32; //for extract - - unsafe{ - filter_ptr += 16; - } - - asm("ldd %0,%1,%2[7]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[0]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[0]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[6]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[1]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[1]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[5]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[2]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[2]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[4]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[3]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[3]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[3]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[4]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[4]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[2]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[5]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[5]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[1]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[6]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[6]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[0]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[7]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[7]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - - unsafe{ - filter_ptr -= 16; - state_ptr += 16; - } - - asm("ldd %0,%1,%2[7]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[0]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[0]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[6]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[1]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[1]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[5]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[2]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[2]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[4]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[3]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[3]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[3]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[4]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[4]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[2]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[5]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[5]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[1]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[6]":"=r"(s2),"=r"(s1):"r"(state_ptr)); - asm("std %0,%1,%2[6]"::"r"(s1), "r"(s0),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s0),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s1),"0"(ah),"1"(al)); - - asm("ldd %0,%1,%2[0]":"=r"(c0),"=r"(c1):"r"(filter_ptr)); - asm("ldd %0,%1,%2[7]":"=r"(s0),"=r"(s3):"r"(state_ptr)); - asm("std %0,%1,%2[7]"::"r"(s3), "r"(s2),"r"(state_ptr)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c0),"r"(s2),"0"(ah),"1"(al)); - asm("maccs %0,%1,%2,%3":"=r"(ah),"=r"(al):"r"(c1),"r"(s3),"0"(ah),"1"(al)); - - asm("lsats %0,%1,%2":"=r"(ah),"=r"(al):"r"(format),"0"(ah),"1"(al)); - asm("lextract %0,%1,%2,%3,32":"=r"(ah):"r"(ah),"r"(al),"r"(format)); - - return ah; -} - -//This block copies the 4 ints from the first stage into stage two FIR state array -//Optimised to 64b using double load/store. Assumes 8 byte alignment. -//It allows the stage 2 FIR to blast straight through without shifting the delay line -static inline void ciruclar_buffer_sim_cpy(int * unsafe src_ptr, int * unsafe dest_ptr){ - unsafe{ - int tmp_0, tmp_1; - //Copy first 2 words - asm volatile("ldd %0,%1,%2[0]":"=r"(tmp_1),"=r"(tmp_0):"r"(src_ptr)); - asm volatile("std %0,%1,%2[0]"::"r"(tmp_1), "r"(tmp_0),"r"(dest_ptr)); - asm volatile("std %0,%1,%2[8]"::"r"(tmp_1), "r"(tmp_0),"r"(dest_ptr)); - //Copy second 2 words - asm volatile("ldd %0,%1,%2[1]":"=r"(tmp_1),"=r"(tmp_0):"r"(src_ptr)); - asm volatile("std %0,%1,%2[1]"::"r"(tmp_1), "r"(tmp_0),"r"(dest_ptr)); - asm volatile("std %0,%1,%2[9]"::"r"(tmp_1), "r"(tmp_0),"r"(dest_ptr)); - } -} - - -// If not MIC_DUAL_ENABLED, cause a link error -#ifdef MIC_DUAL_ENABLED - -static int dc_eliminate(int x, int &prev_x, long long &state){ -#define S 0 -#define N 8 - long long X = x; - long long prev_X = prev_x; - - state = state - (state>>8); - - prev_X<<=32; - state = state - prev_X; - - X<<=32; - state = state + X; - - prev_x = x; - - return (state>>(32-S)); -} - - -#pragma unsafe arrays -void mic_dual_pdm_rx_decimate(buffered in port:32 p_pdm_mic, streaming chanend c_2x_pdm_mic, streaming chanend c_ref_audio[]){ - - //Send initial request to UBM - c_ref_audio[0] <: 0; - c_ref_audio[1] <: 0; - - unsigned delay_line[MIC_DUAL_NUM_CHANNELS][2] = {{0xaaaaaaaa, 0x55555555}, {0xaaaaaaaa, 0x55555555}}; //48 taps, init to pdm zero - int [[aligned(8)]] out_first_stage[MIC_DUAL_NUM_CHANNELS][4] = {{0}}; - - unsigned mid_stage_delay_idx = 0; - const unsigned mid_stage_decimation_factor = 4; - const unsigned mid_stage_ntaps = 16; - int [[aligned(8)]] mid_stage_delay[MIC_DUAL_NUM_CHANNELS][16 * 2]; //Double length for circular buffer simulation - memset(mid_stage_delay, 0, sizeof(mid_stage_delay)); - - int final_stage_in_pcm[MIC_DUAL_NUM_CHANNELS] = {0, 0}; - - unsigned block_sample_count = 0; //Used for assembling blocks from individual samples - unsigned block_buffer_idx = 0; //Optional double buffer for output blocks - - int * unsafe phase_coeff_ptrs[6]; - int [[aligned(8)]] final_stage_delay_poly[MIC_DUAL_NUM_CHANNELS][6][32] = {{{0}}}; - memset(final_stage_delay_poly, 0, sizeof(final_stage_delay_poly)); - unsigned final_stage_phase = 0; - - int pcm_output[MIC_DUAL_NUM_CHANNELS] = {0, 0}; - - int dc_elim_prev[MIC_DUAL_NUM_CHANNELS] = {0, 0}; - long long dc_elim_state[MIC_DUAL_NUM_CHANNELS] = {0, 0}; - - - int output_block[MIC_DUAL_NUM_OUT_BUFFERS][MIC_DUAL_OUTPUT_BLOCK_SIZE][MIC_DUAL_NUM_CHANNELS + MIC_DUAL_NUM_REF_CHANNELS]; - memset(output_block, 0, sizeof(output_block)); - - //Setup nice array of pointers for each phase of coefficients - unsafe{ - for(int i = 0; i < 6; i++) phase_coeff_ptrs[i] = (int * unsafe)&g_third_stage_div_6_fir_dual[i * 32]; - } - - //We are reading in 2 x 32b values in one chunk every 10.4us (96kHz) so we need to 32b storage elements - unsigned port_data[2]; - - while(1) unsafe{ - unsigned t0, t1; - timer t; - - //GET PORT DATA - asm volatile("in %0, res[%1]" : "=r"(port_data[0]) : "r"(p_pdm_mic)); //Use ASM so we avoid SETC instruction - //Input comes in from bit 31 (MSb) and shifts right, so LSB is oldest - t :> t0; - - //UNZIP INTO TWO PDM STREAMS - unsigned long long tmp64 = (unsigned long long) (port_data[0]) << 32 | port_data[1]; - {port_data[0], port_data[1]} = unzip(tmp64, 0); - - //DO FIRST STAGE FIR AND POPULATE BUFFER FOR MID STAGE -#pragma loop unroll - for (int i = 0; i < 4; i++){ - #pragma loop unroll - for (int ch = 0; ch < MIC_DUAL_NUM_CHANNELS; ch++){ - unsigned char pdm = port_data[ch] >> (8 * i); - //printbinln(pdm); - int out_first_stage_tmp = first_stage_fir(pdm, delay_line[ch]); - out_first_stage[ch][i] = out_first_stage_tmp; - //printintln(out_first_stage_tmp); - - } - } - - //CALL MID STAGE FIR - #pragma loop unroll - for (int ch = 0; ch < MIC_DUAL_NUM_CHANNELS; ch++){ - int * first_stage_out_src_ptr = out_first_stage[ch]; - ciruclar_buffer_sim_cpy(first_stage_out_src_ptr, (int * unsafe)&mid_stage_delay[ch][mid_stage_delay_idx]); - } - mid_stage_delay_idx += mid_stage_decimation_factor; //Increment before FIR so we get a proper buffer history - - #pragma loop unroll - for (int ch = 0; ch < MIC_DUAL_NUM_CHANNELS; ch++){ - final_stage_in_pcm[ch] = mid_stage_fir(g_second_stage_fir, mid_stage_delay[ch], mid_stage_delay_idx); - } - //printintln(final_stage_in_pcm[0]); - if (mid_stage_delay_idx == mid_stage_ntaps) { - mid_stage_delay_idx = 0; - } - - //CALL FINAL STAGE POLYPHASE FIR - #pragma loop unroll - for (int ch = 0; ch < MIC_DUAL_NUM_CHANNELS; ch++){ - pcm_output[ch] += final_stage_poly_fir(final_stage_in_pcm[ch], final_stage_delay_poly[ch][final_stage_phase], phase_coeff_ptrs[final_stage_phase]); - } - - //Move on phase of polyFIR and reset if done - final_stage_phase++; - if (final_stage_phase == 6) unsafe{ - //printintln(pcm_output[0]); - - //If we have reached stage 6 then we are ready to send a pair of decimated 16kHz mic signals - //and also receive reference audio - unsigned ref_audio[MIC_DUAL_NUM_REF_CHANNELS]; - select{ - case c_ref_audio[0] :> ref_audio[0]: - for (int ch = 1; ch < MIC_DUAL_NUM_REF_CHANNELS; ch++) c_ref_audio[ch] :> ref_audio[ch]; - //Request some more samples - for (int ch = 0; ch < MIC_DUAL_NUM_REF_CHANNELS; ch++) c_ref_audio[ch] <: 0; - break; - default: - //The host doesn't start sending ref audio for a while at startup so we have to be prepared for nothing on channel - //printstr("."); //This is debug and can be removed - #pragma loop unroll - for (int ch = 0; ch < MIC_DUAL_NUM_REF_CHANNELS; ch++){ - ref_audio[ch] = 0; - } - break; - } - - #pragma loop unroll - for (int ch = 0; ch < MIC_DUAL_NUM_CHANNELS; ch++){ - //Now remove DC and apply some gain - pcm_output[ch] = dc_eliminate(pcm_output[ch], dc_elim_prev[ch], dc_elim_state[ch]); - pcm_output[ch] = (int)( ( (long long)pcm_output[ch] * Q28(MIC_DUAL_GAIN_COMPENSATION) ) >> (28)); - output_block[block_buffer_idx][block_sample_count][ch] = pcm_output[ch]; - } - for (int ch = 0; ch < MIC_DUAL_NUM_REF_CHANNELS; ch++){ - output_block[block_buffer_idx][block_sample_count][MIC_DUAL_NUM_CHANNELS + ch] = ref_audio[ch]; - } - block_sample_count++; - //We have assembled a block so pass a pointer to the consumer - if (block_sample_count == MIC_DUAL_OUTPUT_BLOCK_SIZE){ - c_2x_pdm_mic <: (unsigned)output_block[block_buffer_idx]; - block_sample_count = 0; - block_buffer_idx ^= (MIC_DUAL_NUM_OUT_BUFFERS - 1); //Toggle if double buffer, else do nothing - } - #pragma loop unroll - for (int ch = 0; ch < MIC_DUAL_NUM_CHANNELS; ch++){ - pcm_output[ch] = 0; - } - final_stage_phase = 0; - } - asm volatile("in %0, res[%1]" : "=r"(port_data[1]) : "r"(p_pdm_mic)); - - t :> t1; - //Cycle time at 96kHz is 1041 10ns ticks, which is 650 proc cycles - //if (t1-t0 > 600) printintln(t1-t0); - //printintln(t1-t0); - } -} -#endif diff --git a/lib_mic_array/src/mic_array_setup.c b/lib_mic_array/src/mic_array_setup.c new file mode 100644 index 00000000..c17243c3 --- /dev/null +++ b/lib_mic_array/src/mic_array_setup.c @@ -0,0 +1,75 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "mic_array.h" + +#include +#include +#include +#include +#include + +#include +#include +#include + + +void mic_array_resources_configure( + pdm_rx_resources_t* pdm_res, + int divide) +{ + const unsigned is_ddr = pdm_res->clock_b != 0; + + port_reset(pdm_res->p_mclk); + port_reset(pdm_res->p_pdm_clk); + port_reset(pdm_res->p_pdm_mics); + + clock_enable(pdm_res->clock_a); + port_enable(pdm_res->p_mclk); + clock_set_source_port(pdm_res->clock_a, pdm_res->p_mclk); + clock_set_divide(pdm_res->clock_a, divide/2); + + if(is_ddr){ + clock_enable(pdm_res->clock_b); + clock_set_source_port(pdm_res->clock_b, pdm_res->p_mclk); + clock_set_divide(pdm_res->clock_b, divide/4); + } + + port_enable(pdm_res->p_pdm_clk); + port_set_clock(pdm_res->p_pdm_clk, pdm_res->clock_a); + port_set_out_clock(pdm_res->p_pdm_clk); + + port_start_buffered(pdm_res->p_pdm_mics, 32); + port_set_clock(pdm_res->p_pdm_mics, is_ddr? pdm_res->clock_b + : pdm_res->clock_a); + port_clear_buffer(pdm_res->p_pdm_mics); +} + + +void mic_array_pdm_clock_start( + pdm_rx_resources_t* pdm_res) +{ + if( pdm_res->clock_b != 0 ) { + uint32_t tmp; + + port_clear_buffer(pdm_res->p_pdm_mics); + + /* start the faster capture clock */ + clock_start(pdm_res->clock_b); + + /* wait for a rising edge on the capture clock */ + // (this ensures the rising edges of the two + // clocks are not in phase) + asm volatile("inpw %0, res[%1], 4" : "=r"(tmp) + : "r" (pdm_res->p_pdm_mics)); + + /* start the slower output clock */ + clock_start(pdm_res->clock_a); + } else { + // You'd think that we could move the `clock_start(pdm_res->clock_a)` to be + // after the if..else block instead of duplicating it. But no, if I try + // that, the compiler screws something up and the output audio is all + // messed up. + clock_start(pdm_res->clock_a); + } +} \ No newline at end of file diff --git a/lib_mic_array/src/pdm.xc b/lib_mic_array/src/pdm.xc deleted file mode 100644 index 92309a9d..00000000 --- a/lib_mic_array/src/pdm.xc +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include - -#if DEBUG_MIC_ARRAY -#include "xassert.h" -#include "xs2a_kernel.h" -#endif - -// This counter is synchronous to the PDM clock -// It increments every 64 PDM clock cycles if -// -DUSE_PDM_COUNTER (experimental) is enabled -// in the build. -unsigned pdm_counter=0; - -extern void pdm_rx_asm( - in buffered port:32 p_pdm_mics, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -void mic_array_pdm_rx( - in buffered port:32 p_pdm_mics, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1){ - -#if DEBUG_MIC_ARRAY - unsigned x; - asm("mov %0, %1": "=r"(x):"r"(p_pdm_mics)); - x = XS1_RES_ID_PORTWIDTH(x); - //This interface requires an 8-bit port - if(x != 8) - fail("Invalid port width of p_pdm_mics (PDM input ports)"); -#endif - - //This will never return - pdm_rx_asm(p_pdm_mics, - c_4x_pdm_mic_0,c_4x_pdm_mic_1); -} - -extern void pdm_rx_asm_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -//Not exposed to the API - only intended for testing. -void pdm_rx_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1){ - //This will never return - pdm_rx_asm_debug(c_not_a_port, - c_4x_pdm_mic_0,c_4x_pdm_mic_1); -} diff --git a/lib_mic_array/src/pdm_rx.S b/lib_mic_array/src/pdm_rx.S deleted file mode 100644 index 5e31e11c..00000000 --- a/lib_mic_array/src/pdm_rx.S +++ /dev/null @@ -1,423 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. - .section .dp.data,"awd",@progbits - .text - -.xtacommand "analyse endpoints pdm_rx_4ch_loop_ep pdm_rx_4ch_loop_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ -.xtacommand "analyse endpoints pdm_rx_8ch_loop_ep pdm_rx_8ch_loop_ep","", __FILE__, __LINE__ -.xtacommand "set required - 2604 ns","", __FILE__, __LINE__ - -#define temp_one r0 -#define c_one r1 -#define c_two r2 -#define a r3 -#define b r4 -#define fir0 r5 -#define fir1 r6 -#define fir2 r7 -#define temp_two r8 -#define c r9 -#define p r10 -#define t r11 -#define temp_three r11 - -#include "mic_array_conf.h" - -#ifndef MIC_ARRAY_MUTE_CH_0 -#define MIC_ARRAY_MUTE_CH_0 0 -#endif -#ifndef MIC_ARRAY_MUTE_CH_1 -#define MIC_ARRAY_MUTE_CH_1 0 -#endif -#ifndef MIC_ARRAY_MUTE_CH_2 -#define MIC_ARRAY_MUTE_CH_2 0 -#endif -#ifndef MIC_ARRAY_MUTE_CH_3 -#define MIC_ARRAY_MUTE_CH_3 0 -#endif -#ifndef MIC_ARRAY_MUTE_CH_4 -#define MIC_ARRAY_MUTE_CH_4 0 -#endif -#ifndef MIC_ARRAY_MUTE_CH_5 -#define MIC_ARRAY_MUTE_CH_5 0 -#endif -#ifndef MIC_ARRAY_MUTE_CH_6 -#define MIC_ARRAY_MUTE_CH_6 0 -#endif -#ifndef MIC_ARRAY_MUTE_CH_7 -#define MIC_ARRAY_MUTE_CH_7 0 -#endif - -//This mapping accounts for the muddling of the unzips -//(do not change). -#define PIN0 0 -#define PIN1 4 -#define PIN2 2 -#define PIN3 6 -#define PIN4 1 -#define PIN5 5 -#define PIN6 3 -#define PIN7 7 - - //This mapping allows pins to be mapped to channels -#ifndef MIC_ARRAY_CH0 - #define MIC_ARRAY_CH0 PIN0 -#endif -#ifndef MIC_ARRAY_CH1 - #define MIC_ARRAY_CH1 PIN1 -#endif -#ifndef MIC_ARRAY_CH2 - #define MIC_ARRAY_CH2 PIN2 -#endif -#ifndef MIC_ARRAY_CH3 - #define MIC_ARRAY_CH3 PIN3 -#endif -#ifndef MIC_ARRAY_CH4 - #define MIC_ARRAY_CH4 PIN4 -#endif -#ifndef MIC_ARRAY_CH5 - #define MIC_ARRAY_CH5 PIN5 -#endif -#ifndef MIC_ARRAY_CH6 - #define MIC_ARRAY_CH6 PIN6 -#endif -#ifndef MIC_ARRAY_CH7 - #define MIC_ARRAY_CH7 PIN7 -#endif - -#define STACKWORDS 16 - -#define FIR_BLOCK(P) \ - {ld8u b, p[c]; add a, a, b};\ - {ldw b, P[b];add c, c, 8}; - -#define FIR() \ - {ld8u a, p[c]; ldc b, 0};\ - {ldw a, fir0[a]; add c, c, 8};\ - FIR_BLOCK(fir1)\ - FIR_BLOCK(fir2)\ - FIR_BLOCK(fir2)\ - FIR_BLOCK(fir1)\ - FIR_BLOCK(fir0)\ - {add a, a, b; ldc b, 0} - -#define OUTPUT(I, C)\ - {out res[C], a; ldc c, I} - -.globl pdm_rx_asm_debug -.align 8 -.type pdm_rx_asm_debug,@function -.cc_top pdm_rx_asm_debug.function -pdm_rx_asm_debug: -.cfi_startproc -.issue_mode dual - bu pdm_rx_asm - - .cc_bottom pdm_rx_asm_debug.function - .set pdm_rx_asm_debug.nstackwords, 0 $M pdm_rx_asm.nstackwords - .globl pdm_rx_asm_debug.nstackwords - .set pdm_rx_asm_debug.maxcores, 1 $M pdm_rx_asm.maxcores - .globl pdm_rx_asm_debug.maxcores - .set pdm_rx_asm_debug.maxtimers,0 - .globl pdm_rx_asm_debug.maxtimers - .set pdm_rx_asm_debug.maxchanends,0 - .globl pdm_rx_asm_debug.maxchanends -.Lpdm_rx_asm_debug_tmp: - .size pdm_rx_asm_debug, .Lpdm_rx_asm_debug_tmp-pdm_rx_asm_debug - .cfi_endproc - -.cc_top pdm_rx_asm.function -.globl pdm_rx_asm -.align 4 -.type pdm_rx_asm,@function -pdm_rx_asm://( - //in buffered port:32 p_pdm_mics, - //streaming chanend c, - //streaming chanend ?d, - -.issue_mode dual - DUALENTSP_lu6 STACKWORDS - - stw r0, sp[15] - -#ifdef TEST_MODE - ldc t, 0 -#else - ldc t, 0x5555 - shl t, t, 16; mov c, t - add t, t, c -#endif - std t, t, sp[0] - std t, t, sp[1] - std t, t, sp[2] - std t, t, sp[3] - std t, t, sp[4] - std t, t, sp[5] - - ldaw t, cp[pdm_counter] - stw t, sp[14] - ldaw t, cp[g_first_stage_fir_0] - mov fir0, t - ldaw t, cp[g_first_stage_fir_1] - mov fir1, t - ldaw t, cp[g_first_stage_fir_2] - mov fir2, t - - ldaw p, sp[0] - - ldc c, MIC_ARRAY_CH0 - bt c_two, pdm_rx_8ch_loop - - ldc c, MIC_ARRAY_CH0 - .align 8 -pdm_rx_4ch_loop: - - ldd a, temp_one, sp[7] - {in b, res[a];ldw t, temp_one[0]} - {in a, res[a]; add t, t, 1} -#if USE_PDM_COUNTER - stw t, temp_one[0] -#endif - unzip a, b, 2 - unzip a, b, 1 - unzip a, b, 0 - std a, b, p[0] - - FIR(); - -#if MIC_ARRAY_MUTE_CH_0 - {out res[c_one], b; ldc c,MIC_ARRAY_CH1} -#else - OUTPUT( MIC_ARRAY_CH1, c_one) //output c_one -#endif - - FIR(); - -#if MIC_ARRAY_MUTE_CH_1 - {out res[c_one], b; ldc c, MIC_ARRAY_CH2} -#else - OUTPUT( MIC_ARRAY_CH2, c_one) //output c_one -#endif - - FIR(); - -#if MIC_ARRAY_MUTE_CH_2 - {ldc temp_one, 0; ldc c, MIC_ARRAY_CH3} -#else - {mov temp_one, a; ldc c, MIC_ARRAY_CH3} -#endif - - FIR(); - - {out res[c_one], temp_one} -#if MIC_ARRAY_MUTE_CH_3 - {out res[c_one], b; ldc c, MIC_ARRAY_CH0} -#else - OUTPUT( MIC_ARRAY_CH0, c_one) //output unused0 then this to c_one -#endif - ldd a, b, p[4] - std a, b, p[5] - - ldd a, b, p[3] - std a, b, p[4] - - ldd a, b, p[2] - {bitrev a, a; bitrev b, b} - {byterev a, a; byterev b, b} - std a, b, p[3] - - ldd a, b, p[1] - std a, b, p[2] - - ldd a, b, p[0] - std a, b, p[1] - bl pdm_rx_4ch_loop -//2604ns per loop - .align 8 -pdm_rx_8ch_loop: -//about 6 inst spare without optimisation - - ldd a, temp_one, sp[7] - {in b, res[a];ldw t, temp_one[0]} - {in a, res[a]; add t, t, 1} -#if USE_PDM_COUNTER - stw t, temp_one[0] -#endif - unzip a, b, 2 - unzip a, b, 1 - unzip a, b, 0 - std a, b, p[0] - - FIR(); - -#if MIC_ARRAY_MUTE_CH_0 - {out res[c_one], b; ldc c, MIC_ARRAY_CH4} -#else - OUTPUT( MIC_ARRAY_CH4, c_one) //output c_one -#endif - - FIR(); - -#if MIC_ARRAY_MUTE_CH_4 - {out res[c_two], b; ldc c, MIC_ARRAY_CH1} -#else - OUTPUT( MIC_ARRAY_CH1, c_two) //output c_two -#endif - - FIR(); - -#if MIC_ARRAY_MUTE_CH_1 - {out res[c_one], b; ldc c, MIC_ARRAY_CH5} -#else - OUTPUT( MIC_ARRAY_CH5, c_one) //output c_one -#endif - - FIR(); - -#if MIC_ARRAY_MUTE_CH_5 - {out res[c_two], b; ldc c, MIC_ARRAY_CH2} -#else - OUTPUT( MIC_ARRAY_CH2, c_two) //output c_two -#endif - FIR(); - -#if MIC_ARRAY_MUTE_CH_2 - {ldc temp_one, 0; ldc c, MIC_ARRAY_CH6} -#else - {mov temp_one, a; ldc c, MIC_ARRAY_CH6} -#endif - - FIR(); - -#if MIC_ARRAY_MUTE_CH_6 - {ldc temp_two, 0; ldc c, MIC_ARRAY_CH3} -#else - {mov temp_two, a; ldc c, MIC_ARRAY_CH3} -#endif - - FIR(); - -#if MIC_ARRAY_MUTE_CH_3 - {ldc temp_three, 0; ldc c, MIC_ARRAY_CH7} -#else - {mov temp_three, a; ldc c, MIC_ARRAY_CH7} -#endif - - FIR(); - - - {out res[c_one], temp_one} - - {out res[c_two], temp_two} - - {out res[c_one], temp_three; ldc b, 0} - -#if MIC_ARRAY_MUTE_CH_7 - {out res[c_two], b; ldc c, MIC_ARRAY_CH0} -#else - OUTPUT( MIC_ARRAY_CH0, c_two) -#endif - - - ldd a, b, p[4] - std a, b, p[5] - - ldd a, b, p[3] - std a, b, p[4] - - ldd a, b, p[2] - {bitrev a, a; bitrev b, b} - {byterev a, a; byterev b, b} - std a, b, p[3] - - ldd a, b, p[1] - std a, b, p[2] - - ldd a, b, p[0] - std a, b, p[1] - bl pdm_rx_8ch_loop - -.pdm_rx_asm_tmp: - .size pdm_rx_asm, .pdm_rx_asm_tmp-pdm_rx_asm - .align 4 - .cc_bottom pdm_rx_asm.function - - .set pdm_rx_asm.nstackwords, STACKWORDS - .globl pdm_rx_asm.nstackwords - .set pdm_rx_asm.maxcores,1 - .globl pdm_rx_asm.maxcores - .set pdm_rx_asm.maxtimers,0 - .globl pdm_rx_asm.maxtimers - .set pdm_rx_asm.maxchanends,0 - .globl pdm_rx_asm.maxchanends - - -#define EPT_MARCO(ID, PASS) \ -.cc_top cc_a ## ID ## _ ## PASS,input_ ## ID ## _ ## PASS ;\ - .ascii "";\ - .byte 0;\ - .long 0;\ - .long input_ ## ID ## _ ## PASS;\ -.cc_bottom cc_a ## ID ## _ ## PASS - - .section .xtaendpoint,"",@progbits -.Lentries_start0: - .long .Lentries_end0-.Lentries_start0 - .long 1 - .ascii "" - .byte 0 - - .ascii "pdm_rx_4ch_loop_ep" - .byte 0 - .ascii "" - .byte 0 - .long 0 - .long .Laddr_end0 -.Laddr_start0 - .Laddr_start0: - .cc_top cc_0 ,pdm_rx_4ch_loop - .long pdm_rx_4ch_loop - .byte 0 - .cc_bottom cc_0 - .Laddr_end0 : - - .ascii "pdm_rx_8ch_loop_ep" - .byte 0 - .ascii "" - .byte 0 - .long 0 - .long .Laddr_end1 -.Laddr_start1 - .Laddr_start1: - .cc_top cc_1 ,pdm_rx_8ch_loop - .long pdm_rx_8ch_loop - .byte 0 - .cc_bottom cc_1 - .Laddr_end1 : -.Laddr_end9: - -.Lentries_end0: - - .section .xtaendpointtable,"",@progbits -.Lentries_start1: - .long .Lentries_end1-.Lentries_start1 - .long 0 - .ascii "" - .byte 0 - -.cc_top cc_a0,pdm_rx_4ch_loop - .ascii "" - .byte 0 - .long 0 - .long pdm_rx_4ch_loop -.cc_bottom cc_a0 - -.cc_top cc_a1,pdm_rx_8ch_loop - .ascii "" - .byte 0 - .long 0 - .long pdm_rx_8ch_loop -.cc_bottom cc_a1 - - -.Lentries_end1: - diff --git a/lib_mic_array/src/pdm_rx_isr.S b/lib_mic_array/src/pdm_rx_isr.S new file mode 100644 index 00000000..25d2e045 --- /dev/null +++ b/lib_mic_array/src/pdm_rx_isr.S @@ -0,0 +1,106 @@ +// Copyright 2021-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#if defined(__XS3A__) + +/* + + File contains the ISR logic for capturing PDM samples coming in. + +*/ + + + +.section .dp.data, "awd", @progbits + +.align 8 +pdm_rx_isr_context: +.L_port: .word 0 +.L_buffA: .word 0 +.L_buffB: .word 0 +.L_phase1: .word 0 +.L_phase1_reset: .word 0 +.L_c_out: .word 0 +.L_credit: .word 0 +.L_missed_blocks: .word -1 + +.global pdm_rx_isr_context + + +#define NSTACKWORDS 4 + + +.text +.issue_mode single +.align 16 // 16-byte alignment guarantees that FNOPs always happen in the same spots + +#define A r4 +#define B r5 +#define C r6 +#define D r7 + +.cc_top pdm_rx_isr.function,pdm_rx_isr +pdm_rx_isr: + extsp 4 + stw r4, sp[0]; stw r5, sp[1] + stw r6, sp[2]; stw r7, sp[3] + // Read port data + ldw A, dp[.L_port] + in A, res[A] + // Place in PDM buffer + ldw D, dp[.L_buffA] + ldw C, dp[.L_phase1] + stw A, D[C] + // If full, emit the buffer + bf C, .L_emit + // Decrement phase and return + sub C, C, 1 + stw C, dp[.L_phase1] + ldw r4, sp[0]; ldw r5, sp[1] + ldw r6, sp[2]; ldw r7, sp[3] + ldaw sp, sp[NSTACKWORDS] + kret + .L_emit: + // Reset phase1 number + ldw A, dp[.L_phase1_reset] + stw A, dp[.L_phase1] + // Swap PDM buffers A and B + ldw A, dp[.L_buffB] + stw A, dp[.L_buffA] + stw D, dp[.L_buffB] + // Next set of samples is ready. + + // Check if there is currently send credit, and if not, quietly drop the + // pdm block. This prevents a possible deadlock if the main thread gets + // backed up. + ldw A, dp[.L_credit] + bt A, .L_has_credit + .L_no_credit: + // No credit. increment the missed block counter. + ldw A, dp[.L_missed_blocks] + not D, A // if the missed blocks counter is set to -1 (default) + ecallf D // then dropping a block is a crashable offense + add A, A, 1 + stw A, dp[.L_missed_blocks] + bu .L_finish + .L_has_credit: + sub A, A, 1 + stw A, dp[.L_credit] + + ldw A, dp[.L_c_out] + out res[A], D + + .L_finish: + // And we're done + ldw r4, sp[0]; ldw r5, sp[1] + ldw r6, sp[2]; ldw r7, sp[3] + ldaw sp, sp[NSTACKWORDS] + kret +.L_func_end: +.cc_bottom pdm_rx_isr.function + +.global pdm_rx_isr + +#endif //defined(__XS3A__) + + diff --git a/python/setup.py b/python/setup.py deleted file mode 100644 index 8181e870..00000000 --- a/python/setup.py +++ /dev/null @@ -1,31 +0,0 @@ -# Copyright 2020-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import setuptools - -# Another repository might depend on python code defined in this one. The -# procedure to set up a suitable python environment for that repository may -# pip-install this one as editable using this setup.py file. To minimise the -# chance of version conflicts while ensuring a minimal degree of conformity, -# the 3rd-party modules listed here require the same major version and at -# least the same minor version as specified in the requirements.txt file. -# The same modules should appear in the requirements.txt file as given below. -setuptools.setup( - name='lib_mic_array', - packages=setuptools.find_packages(), - install_requires=[ - "flake8~=3.8", - "matplotlib~=3.3", - "numpy~=1.18", - "pylint~=2.5", - "pytest~=6.0", - "pytest-xdist~=1.34", - "scipy~=1.4", - "lib_logging", - "lib_xassert", - ], - - dependency_links=[ - './../lib_logging#egg=lib_logging', - './../lib_xassert#egg=lib_xassert', - ], -) diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 2e52a4d4..00000000 --- a/requirements.txt +++ /dev/null @@ -1,44 +0,0 @@ -# python_version 3.7.6 -# -# The parse_version_from_requirements() function in the installPipfile.groovy -# file of the Jenkins Shared Library uses the python_version comment to set -# the version of python used. - -# Distributed (released) dependencies -# -# The python modules listed below specify a known working combination required -# by the python code in this repository. The procedure used to set up a -# suitable python environment for it installs the version of each module in -# the list. Using a specific version ensures a controlled infrastructure for -# development, testing and release of this repository. -# -# Another repository might depend on python code defined in this one. The -# procedure to set up a suitable python environment for that repository may -# pip-install this one as editable using this repository's setup.py file. The -# same modules should appear in the setup.py list as given below. -flake8==3.8.3 -matplotlib==3.3.1 - -# Pin numpy to 1.18.5 due to tensorflow v2.1.1 hard pinning it to that version. -numpy==1.18.5 -pylint==2.5.3 -pytest==6.0.0 -pytest-xdist==1.34.0 - -# Pin scipy to 1.4.1 due to tensorflow v2.1.1 hard pinning it to that version. -scipy==1.4.1 - -# Development dependencies -# -# Each link listed below specifies the path to a setup.py file which are -# installed in editable mode with '-e $PATH' (without the quotes). -# -# If python code in this repository depends on python code under development -# in another repository, then an entry for that other respository should -# appear in this list instead of the released dependencies list. -# -# If this repository uses the setup functionality (e.g., script entry points) -# of its own setup.py file, then this list must include an entry for that -# setup.py file, e.g., '-e .' or '-e ./python' (without the quotes). --e ./../lib_logging --e ./../lib_xassert diff --git a/script/mic_array/__init__.py b/script/mic_array/__init__.py new file mode 100644 index 00000000..4f4da1ea --- /dev/null +++ b/script/mic_array/__init__.py @@ -0,0 +1,3 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + diff --git a/script/mic_array/case_replay.py b/script/mic_array/case_replay.py new file mode 100644 index 00000000..683432b9 --- /dev/null +++ b/script/mic_array/case_replay.py @@ -0,0 +1,74 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +""" +Module to make it easier to take replay failing test cases. + +CaseReplay class is instantiated in one of three modes -- do-nothing (default), +save-vectors, or load-vectors. + +Do-nothing does nothing with signals -- neither saves nor loads them. Save-vectors +will store a case's random vectors/values so that they can be loaded on a subsequent +run. Load-vectors loads them from file. +""" +import numpy as np +import pickle, os, sys, enum + +class ReplayMode(enum.Enum): + DO_NOTHING = 0 + SAVE_VECTORS = 1 + LOAD_VECTORS = 2 + +class NoSignalToLoadException(Exception): + pass + + +def InitReplay(case_name: str, mode: ReplayMode = ReplayMode.DO_NOTHING): + return CaseReplay(case_name, mode) + +class CaseReplay(object): + CASE_DIR = f"./case_replay.local/" + + def __init__(self, case_name: str, mode: ReplayMode = ReplayMode.DO_NOTHING): + self.case_name = case_name + self.case_path = os.path.join(CaseReplay.CASE_DIR, self.case_name) + self.vectors = dict() + self.mode = mode + + def __enter__(self): + # Nothing to do on entry unless we're loading. + if self.mode == ReplayMode.LOAD_VECTORS: + os.makedirs(CaseReplay.CASE_DIR, exist_ok=True) + if not os.path.exists(self.case_path): + raise NoSignalToLoadException(f"File {self.case_path} does not exist.") + + with open(self.case_path, 'rb') as file_in: + self.vectors = pickle.load(file_in) + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + # Nothing to do on exit unless we're saving. + if self.mode == ReplayMode.SAVE_VECTORS: + os.makedirs(CaseReplay.CASE_DIR, exist_ok=True) + with open(self.case_path, 'wb') as file_out: + pickle.dump(self.vectors, file_out) + + def apply(self, vec_name: str, vector): + """ + The model here is to call apply() on a signal in a test case *after* it has + already been given a random value. In the test case, the signal variable is + assigned the result of that call. If we're in load-vectors mode, it'll + replace the signal with the value in the saved file (if it exists; otherwise + an exception will be raised). If we're in save-vectors mode, the signal will + be added to the dictionary to be saved on __exit__(), and then returned + unmodified. In do-nothing mode it will just be returned unmodified. + """ + if self.mode == ReplayMode.LOAD_VECTORS: + if vec_name not in self.vectors: + raise NoSignalToLoadException(f"Vector named {vec_name} not found for case {self.case_name}.") + vector = self.vectors[vec_name] + + elif self.mode == ReplayMode.SAVE_VECTORS: + self.vectors[vec_name] = vector + + return vector \ No newline at end of file diff --git a/script/mic_array/device_context.py b/script/mic_array/device_context.py new file mode 100644 index 00000000..7f65ee40 --- /dev/null +++ b/script/mic_array/device_context.py @@ -0,0 +1,91 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import os, signal, subprocess +from . import xscope + + +class DeviceContext(object): + + GDB_SCRIPT = os.path.join(os.path.dirname(os.path.realpath(__file__)), + 'gdb_script.gdb') + XGDB_CMD_BASE = ('xgdb', '-q', '--return-child-result', + '--ex=set $xcore_id=0', + '--ex=set $xcore_boot=0', + '-x', GDB_SCRIPT, '--ex', 'quit') + + def __init__(self, xe_path, /, probes=[], **kwargs): + + self.xe_path = xe_path + self.xgdb_cmd = list(DeviceContext.XGDB_CMD_BASE) + [self.xe_path] + + self.xgdb = None + self.ep = xscope.Endpoint() + + self.probe_timeout = ( 10.0 if "probe_timeout" not in kwargs + else kwargs["probe_timeout"] ) + + self.probes = { k: xscope.QueueConsumer(self.ep, k, + probe_timeout=self.probe_timeout) for k in probes } + + self.connect_retries = ( 5 if "connect_retries" not in kwargs + else kwargs["connect_retries"] ) + + self.quiet_xgdb = ( True if "quiet_xgdb" not in kwargs + else kwargs["quiet_xgdb"] ) + + def _on_connect(self): + pass # for subclasses to override + + def __enter__(self): + + if self.quiet_xgdb: + self.xgdb = subprocess.Popen(self.xgdb_cmd, stdout=subprocess.DEVNULL) + else: + self.xgdb = subprocess.Popen(self.xgdb_cmd) + + try: + for _ in range(self.connect_retries): + c = self.ep.connect() + if not c: break + print("Retrying..") + if c: + print("Failed to connect to xgdb.") + self.ep = None + raise Exception("Failed to connect to xgdb.") + self._on_connect() + except: + # self.xgdb.send_signal(signal.CTRL_C_EVENT) + self.xgdb.terminate() + self.xgdb = None + raise + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + if self.ep is not None: + try: self.ep.disconnect() + except: pass + if self.xgdb is not None: + try : + # self.xgdb.send_signal(signal.CTRL_C_EVENT) + self.xgdb.terminate() + self.xgdb = None + except: + pass + + def send_bytes(self, data): + if len(data) == 0: + self.ep.publish(data) + return + + while (len(data) > 0): + self.ep.publish(data[:128]) + data = data[128:] + + def send_word(self, word): + self.send_bytes(int(word).to_bytes(4,'little')) + + def probe_next(self, probe, count=1): + return self.probes[probe].next(count) + + diff --git a/script/mic_array/filters.py b/script/mic_array/filters.py new file mode 100644 index 00000000..f7b255bc --- /dev/null +++ b/script/mic_array/filters.py @@ -0,0 +1,284 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import numpy as np +import pickle as pkl +from . import util + + +def VLMACCR1(vC: np.ndarray, mem: np.ndarray, acc = 0, **kwargs) -> np.int32: + # vC and mem should both be binary {0,1} vectors that are 256 elements + assert vC.ndim == 1 + assert mem.ndim == 1 + assert len(vC) == 256 + assert len(mem) == 256 + + q = np.int(1)*(~(vC == mem)) + popcount_xor = np.sum(q) + return acc + (128 - popcount_xor) + + + +class Stage1Filter(object): + + INT16_MAX_COEFFICIENT = 32766 + BLOCK_SIZE = 256 + + def __init__(self, coefs: np.ndarray, decimation_factor: int = 32): + assert (coefs.ndim == 1), "Stage1Filter coefs must be a single dimensional ndarray" + assert (len(coefs) % Stage1Filter.BLOCK_SIZE == 0), f"Stage1Filter must have a multiple of 256 coefficients ({len(coefs)})" + + t = np.argmax(np.abs(coefs)) + + assert (np.abs(coefs[t]) <= 1.0), "Stage1Filter coefficients must be scaled to the range [-1.0, 1.0]" + + # The decimation factor + self.dec_factor = decimation_factor + + # The coefficients themselves + self.coefs = coefs + + # The scale factor for scaling to int16 + self.scale_int16 = Stage1Filter.INT16_MAX_COEFFICIENT / self.coefs[t] + + # The int16 filter coefficients + # self.scale_int16 = (Stage1Filter.INT16_MAX_COEFFICIENT * (1 if coefs[t] >= 0 else -1)) / coefs[t] + self.coefs_int16 = np.round(self.scale_int16 * self.coefs).astype(np.int16) + + # The bipolar {-1,1} filter coefficient representation + self.coefs_bipolar = util.int16_vect_to_bipolar_matrix(self.coefs_int16, util.int16_dual) + + # The binary {1,0} filter coefficient representation + # (note that the binary matrix is from the bipolar transposed) + self.coefs_binary = (1-self.coefs_bipolar.T)//2 + + @property + def DecimationFactor(self): + return self.dec_factor + + @property + def TapCount(self): + return len(self.coefs) + + @property + def BlockCount(self): + return len(self.coefs) // Stage1Filter.BLOCK_SIZE + + @property + def Coef(self): + return self.coefs + + @property + def CoefInt16(self): + return self.coefs_int16 + + @property + def ScaleInt16(self): + return self.scale_int16 + + @property + def CoefBipolar(self): + return self.coefs_bipolar + + @property + def CoefBinary(self): + return self.coefs_binary + + def _pad_input(self, sig_in): + if sig_in.ndim == 1: + sig_in = sig_in[np.newaxis,:] + CHANS,SAMP_IN = sig_in.shape + Q = self.DecimationFactor + P = self.TapCount - Q + S = np.zeros((CHANS, P+SAMP_IN), dtype=sig_in.dtype) + S[:,:P] = (2*(np.arange(P) % 2) - 1).astype(sig_in.dtype) + S[:,P:] = sig_in + return S + + def FilterFloat(self, pdm_signal: np.ndarray) -> np.ndarray: + if pdm_signal.ndim == 1: + pdm_signal = pdm_signal[np.newaxis,:] + CHANS, SAMPS_IN = pdm_signal.shape + Q = self.DecimationFactor + N_pcm = SAMPS_IN // self.DecimationFactor + + S = self._pad_input(pdm_signal) + coefs = self.Coef.astype(np.float)[:,np.newaxis] + res = np.zeros((CHANS,N_pcm), dtype=np.float) + for k in range(N_pcm): + x = S[:,Q*k:Q*k+self.TapCount] + res[:,k] = np.matmul(x, coefs).squeeze() + return res + + def FilterInt16(self, pdm_signal: np.ndarray) -> np.ndarray: + if pdm_signal.ndim == 1: + pdm_signal = pdm_signal[np.newaxis,:] + CHANS, SAMPS_IN = pdm_signal.shape + Q = self.DecimationFactor + N_pcm = SAMPS_IN // self.DecimationFactor + + S = self._pad_input(pdm_signal) + coefs = self.CoefInt16.astype(np.int32)[:,np.newaxis] + res = np.zeros((CHANS, N_pcm), dtype=np.int32) + for k in range(N_pcm): + x = S[:,Q*k:Q*k+self.TapCount] + res[:,k] = np.matmul(x, coefs).squeeze() + return (res << 8) # stage1 does this on device + + def ToXCoreCoefArray(self): + + B = self.CoefBinary + B = B.reshape((B.size // 256, 8, 32)).astype(np.uint32) + B = np.flip(B, axis=1) + B = np.flip(B, axis=2) + B = B.reshape((B.size // 32, 32)) + N = B.shape[0] + y = np.zeros(N, dtype=np.uint32) + + F = (2**np.arange(32)).astype(np.uint32)[::-1] + + for k in range(N): + y[k] = np.dot(F, B[k,:]) + + return y + + + + + +class Stage2Filter(object): + + INT32_MAX_COEFFICIENT = (2**31)-1 + + def __init__(self, coefs: np.ndarray, decimation_factor: int): + + assert (coefs.ndim == 1), "Stage2Filter coefs must be a single dimensional ndarray" + + t = np.argmax(np.abs(coefs)) + + assert (np.abs(coefs[t]) <= 1.0), "Stage2Filter coefficients must be scaled to the range [-1.0, 1.0]" + + # The decimation factor + self.dec_factor = decimation_factor + + # The coefficients themselves + self.coefs = coefs + + # The scale factor for scaling to int32 + self.scale_int32 = Stage2Filter.INT32_MAX_COEFFICIENT / self.coefs[t] + + # The int32 filter coefficients + self.coefs_int32 = np.round(self.scale_int32 * self.coefs).astype(np.int32) + + # The right-shift required for fixed-point output scaling + # (the 0x7FFFFF00 is the largest value a 1-block Stage1 filter can output) + max_samp_out = np.dot( np.int64( 0x7FFFFF00) * np.sign(self.coefs_int32).astype(np.int64), + np.round(self.coefs_int32 / 2**30).astype(np.int64) ) + frac_shr = np.log2(max_samp_out) - 30 + self.shr_int32 = np.int(np.floor(frac_shr)) + + + @property + def DecimationFactor(self): + return self.dec_factor + + @property + def TapCount(self): + return len(self.coefs) + + @property + def Coef(self): + return self.coefs + + @property + def CoefInt32(self): + return self.coefs_int32 + + @property + def ScaleInt32(self): + return self.scale_int32 + + @property + def ShrInt32(self): + return self.shr_int32 + + def _pad_input(self, sig_in): + if sig_in.ndim == 1: + sig_in = sig_in[np.newaxis,:] + CHANS,SAMP_IN = sig_in.shape + Q = self.DecimationFactor + P = self.TapCount - Q + S = np.zeros((CHANS, P+SAMP_IN), dtype=sig_in.dtype) + S[:,P:] = sig_in + return S + + def FilterFloat(self, signal_in: np.ndarray) -> np.ndarray: + if signal_in.ndim == 1: + signal_in = signal_in[np.newaxis,:] + CHANS, SAMPS_IN = signal_in.shape + Q = self.DecimationFactor + SAMPS_OUT = SAMPS_IN // self.DecimationFactor + + S = self._pad_input(signal_in) + res = np.zeros((CHANS,SAMPS_OUT), dtype=np.float) + coefs = np.flip(self.Coef.astype(np.float))[:,np.newaxis] + for k in range(SAMPS_OUT): + x = S[:,Q*k:Q*k+self.TapCount] + res[:,k] = np.matmul( x, coefs ).squeeze() + return res + + def FilterInt32(self, signal_in: np.ndarray) -> np.ndarray: + if signal_in.ndim == 1: + signal_in = signal_in[np.newaxis,:] + CHANS, SAMPS_IN = signal_in.shape + Q = self.DecimationFactor + SAMPS_OUT = SAMPS_IN // self.DecimationFactor + + S = self._pad_input(signal_in) + res = np.zeros((CHANS,SAMPS_OUT), dtype=np.int32) + coefs = np.flip(self.CoefInt32.astype(np.int64))[:,np.newaxis] + for k in range(SAMPS_OUT): + x = S[:,Q*k:Q*k+self.TapCount] + p = np.matmul(x, coefs) + # astew: Note that this is not precisely the logic used in lib_xcore_math to + # apply the second stage filter (via xs3_filter_s32()). But I'd + # rather compare device behavior to the correct result (which this + # gives) than get bit-identical results in a way that masks the fact + # that the filter isn't perfect. + res[:,k] = np.round( p * 2**(-30-self.shr_int32) ).astype(np.int32).squeeze() + return res + + +class TwoStageFilter(object): + + def __init__(self, s1_filter: Stage1Filter, s2_filter: Stage2Filter): + self.s1 = s1_filter + self.s2 = s2_filter + + @property + def DecimationFactor(self): + return self.s1.DecimationFactor * self.s2.DecimationFactor + + def Filter(self, pdm_signal: np.ndarray) -> np.ndarray: + s1_output = self.s1.FilterInt16(pdm_signal) + return self.s2.FilterInt32(s1_output) + + + + +def load(coef_file: str, /, truncate_s1=False): + + with open(coef_file, "rb") as pkl_file: + # Split the pickled data into the stage1 and stage2 values + stage1, stage2 = pkl.load(pkl_file) + + if truncate_s1: + p = len(stage1[0]) % Stage1Filter.BLOCK_SIZE + stage1[0] = stage1[0][:-p] + + s1_filter = Stage1Filter(stage1[0], stage1[1]) + s2_filter = Stage2Filter(stage2[0], stage2[1]) + return s1_filter, s2_filter + + + diff --git a/script/mic_array/gdb_script.gdb b/script/mic_array/gdb_script.gdb new file mode 100644 index 00000000..b9422816 --- /dev/null +++ b/script/mic_array/gdb_script.gdb @@ -0,0 +1,11 @@ +set confirm off +set width -1 +set height -1 +connect --xscope-port-blocking --xscope-port localhost:10234 +load + if ($xcore_boot != 0) + detach + else + continue + + end \ No newline at end of file diff --git a/script/mic_array/pdm_signal.py b/script/mic_array/pdm_signal.py new file mode 100644 index 00000000..8b384fdf --- /dev/null +++ b/script/mic_array/pdm_signal.py @@ -0,0 +1,101 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import os +import numpy as np + +class PdmSignal(object): + """ + Class represents an N-channel PDM signal. Basically a numpy.ndarray with some + logic checks and helper functions. + """ + + def __init__(self, signal: np.ndarray): + assert signal.ndim <= 2 + if signal.ndim == 1: + signal = signal.reshape((1,len(signal))) + assert np.all( np.logical_or((signal==1), (signal==-1)) ) + assert(signal.shape[0] in {1,2,4,8,16}) + self.signal = signal.astype(np.int32) + + @property + def len(self): + return self.signal.shape[1] + + def block_count(self, total_decimation_factor): + return self.len // total_decimation_factor + + + @staticmethod + def random(chans: int, samps: int): + assert(chans in {1, 2, 4, 8, 16}) + assert(samps % 32 == 0) + + N_bits = chans * samps + N_bytes = N_bits // 8 + + sig = os.urandom(N_bytes) + sig = np.unpackbits(np.frombuffer(sig, dtype=np.uint8), + bitorder='little').astype(int) + sig = sig.reshape((chans,samps)) + sig = 1-(2*sig) + return PdmSignal(sig) + + def to_binary(self) -> np.ndarray: + """ + Convert the bipolar {-1,+1} PDM signal into a binary {0,1} signal, using the + mapping: {+1 --> 0, -1 --> 1} + """ + return (1-self.signal)//2 + + def to_bytes(self, s2_dec_factor): + """ + Convert PDM signal into sequence of words which is directly consumable by + the decimator + + Decimator expects a sequence of PDM data blocks, where each block contains + chan_count*s2_dec_factor words of PDM data, and each block is formated as: + + uint32_t block[CHAN_COUNT][S2_DEC_FACTOR] + + where the channels are in-order and words within a channel are in order of + occurance. + + Note that for each bit value in the result, 0 represents +1, and 1 + represents -1. + """ + # first, convert to binary values + sig = self.to_binary().astype(np.uint32) + CHAN_COUNT = sig.shape[0] + SAMP_COUNT = sig.shape[1] + BLOCKS = SAMP_COUNT // (32 * s2_dec_factor) + TOTAL_WORDS = SAMP_COUNT * CHAN_COUNT // 32 + sig = np.apply_along_axis(lambda x: np.dot(x, 2**np.arange(32,dtype=np.uint32)), 2, + sig.reshape((CHAN_COUNT, SAMP_COUNT//32, 32))) + sig = sig.transpose() + sig = sig.reshape((BLOCKS, s2_dec_factor, CHAN_COUNT)) + sig = sig.transpose(0,2,1) + sig = sig.reshape(TOTAL_WORDS) + sig = sig.tobytes() + return sig + + + def to_bytes_interleaved(self): + """ + Convert PDM signal into sequence of words which is directly consumable by + the mic array PdmRx + + Note that for each bit value in the result, 0 represents +1, and 1 + represents -1. + """ + sig = self.to_binary() + CHAN_COUNT = sig.shape[0] + SAMP_COUNT = sig.shape[1] + SPW = 32 // CHAN_COUNT + + sig = np.apply_along_axis(lambda x: np.dot(x, 2**np.arange(CHAN_COUNT)), 0, sig) + sig = sig.reshape(SAMP_COUNT//SPW, SPW) + + return np.apply_along_axis(lambda x: np.dot(x, + 2**(CHAN_COUNT * np.arange(SPW))), 1, sig).tobytes() + diff --git a/script/mic_array/util.py b/script/mic_array/util.py new file mode 100644 index 00000000..2dc2c5d4 --- /dev/null +++ b/script/mic_array/util.py @@ -0,0 +1,51 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import numpy as np +import struct + +# Turn integer array into array of bits +def bits_array(x): + return np.unpackbits(np.frombuffer(x.tobytes(), dtype=np.uint8), bitorder='little').astype(int) + +# This is the dual vector whose inner product with a binary {-1, 1} vector +# produces the int16 being represented. +int16_dual = np.array([0x0001, 0x0002, 0x0004, 0x0008, + 0x0010, 0x0020, 0x0040, 0x0080, + 0x0100, 0x0200, 0x0400, 0x0800, + 0x1000, 0x2000, 0x4000, 0x7FFF], dtype=np.int) + +# Find the bipolar matrix representation B[,] of an int16 vector x[] which satisfies +# (np.matmul(B[:,:], dual_vector[:]) / 2) == x[:] +# If len(x) == N, then the returned matrix B[,] will have shape (N, 16). +# The first column, B[k,0], must correspond to the LEAST significant bit of the +# transformed coefficient x[k] +def int16_vect_to_bipolar_matrix(x, dual_vector): + x = x.astype(np.int64) + y = 2*x[:,0] if (len(x.shape)==2) else 2*x + res = np.zeros((len(y), 16), dtype=np.int) + for k in range(15,-1,-1): + p = (y >= 0) * 2 - 1 + res[:,k] = p + y = y - p * dual_vector[k] + return res + + +def pdm_signal_from_file(fname: str, /, binary=False): + + with open(fname, 'rb') as file: + data = file.read() + N_words = len(data) // 4 + signal_words = np.array( struct.unpack("I"*N_words, data), dtype=np.uint32 ) + + # signal_words is the sequence of 32-bit words that are delivered by the port. Later words were received later. + # The MSb of each word is the latest sample. Taken together, these mean that bit index k or word j is the + # (32*j+k)'th PDM sample + + N_pdm = len(signal_words) * 32 + signal_pdm = np.unpackbits(np.frombuffer(signal_words.tobytes(), dtype=np.uint8), bitorder='little') + + if not binary: + signal_pdm = (1 - 2*signal_pdm.astype(np.int32)).astype(np.int32) + + return signal_pdm \ No newline at end of file diff --git a/script/mic_array/xscope.py b/script/mic_array/xscope.py new file mode 100644 index 00000000..31edbd3d --- /dev/null +++ b/script/mic_array/xscope.py @@ -0,0 +1,256 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import os, ctypes, platform, sys, time, queue +from collections import defaultdict +import ctypes.util +import numpy as np + +""" + Function prototypes to match the c functions defined in xscope_endpoint.h +""" +PRINT_CALLBACK = ctypes.CFUNCTYPE( + None, + ctypes.c_ulonglong, # timestamp + ctypes.c_uint, # length + ctypes.c_char_p) # data + +RECORD_CALLBACK = ctypes.CFUNCTYPE( + None, + ctypes.c_uint, # id + ctypes.c_ulonglong, # timestamp + ctypes.c_uint, # length + ctypes.c_ulonglong, # dataval + ctypes.c_char_p) # databytes + +REGISTER_CALLBACK = ctypes.CFUNCTYPE( + None, + ctypes.c_uint, # id + ctypes.c_uint, # type + ctypes.c_uint, # r + ctypes.c_uint, # g + ctypes.c_uint, # b + ctypes.c_char_p, # name + ctypes.c_char_p, # unit + ctypes.c_uint, # data_type + ctypes.c_char_p) # data_name + +STATS_CALLBACK = ctypes.CFUNCTYPE( + None, + ctypes.c_uint, # id + ctypes.c_ulonglong) # average + +class Endpoint(object): + """Python xSCOPE endpoint wrapper. + + Example: + + def my_callback(timestamp, probe, value): + print '{} {} {}'.format(timestamp, probe, value) + + ep = Endpoint() + + try: + if ep.connect('localhost', '12345'): + print "Failed to connect" + else: + ep.consume(callback, 'my_probe") + while(True): + pass + + except KeyboardInterrupt: + ep.disconnect() + """ + def __init__(self): + self._probe_info = {} # probe id to probe info lookup. + # probe_info includes name, units, data type, etc... + self._consumers = defaultdict(set) # probe name -> callbacks lookup + #NOTE: The consumers must be looked up by name and not id because + # they can be specified before the probe_info is defined + + tool_path = os.environ.get('XMOS_TOOL_PATH') + ps = platform.system() + if ps == 'Windows': + lib_path = os.path.join(tool_path, 'lib', 'xscope_endpoint.dll') + else: # Darwin (aka MacOS) or Linux + lib_path = os.path.join(tool_path, 'lib', 'xscope_endpoint.so') + self.lib_xscope = ctypes.CDLL(lib_path) + + # create callbacks + self._print_cb = self._print_callback_func() + self.lib_xscope.xscope_ep_set_print_cb(self._print_cb) + + self._record_cb = self._record_callback_func() + self.lib_xscope.xscope_ep_set_record_cb(self._record_cb) + + self._register_cb = self._register_callback_func() + self.lib_xscope.xscope_ep_set_register_cb(self._register_cb) + + self._stats_cb = self._stats_callback_func() + self.lib_xscope.xscope_ep_set_stats_cb(self._stats_cb) + + def _print_callback_func(self): + def func(timestamp, length, data): + self.on_print(timestamp, data[0:length]) + return PRINT_CALLBACK(func) + + def _register_callback_func(self): + def func(id_, type_, r, g, b, name, unit, data_type, data_name): + self._probe_info[id_] = { + 'type': type_, + 'name': name.decode(), + 'unit': unit, + 'data_type': data_type + } + self.on_register(id_, type_, name, unit, data_type) + return REGISTER_CALLBACK(func) + + def _record_callback_func(self): + def func(id_, timestamp, length, data_val, data_bytes): + self.on_record(id_, timestamp, length, data_val, data_bytes) + return RECORD_CALLBACK(func) + + def _stats_callback_func(self): + def func(id_, average): + #TODO + pass + return STATS_CALLBACK(func) + + def on_print(self, timestamp, data): + """xScope printf handler. + Override this to method to implement your own printing or to silence the printout. + """ + print("DEV: " + data.decode().rstrip()) + + def on_register(self, id_, type_, name, unit, data_type): + """Server probe registration handler. + Override this to method to implement your own registration or to silence the printout. + """ + print('Probe registered: id={}, type={}, name={}, unit={}, data_type={}'.format(id_, type_, name, unit, data_type)) + + def on_record(self, id_, timestamp, length, data_val, data_bytes): + """Server record handler. Will dispatch to probe consumer callback. + Override this to method to implement your own dispatcher. However, + that should rarely be necessary. + """ + # For some reason negative values keep getting interpreted as UINT64 + # which messes everything up. This seems to fix it. + data_val = np.int32(np.uint32(data_val & 0xFFFFFFFF)) + def notify_consumers(consumers, probe_name): + for cb in consumers: + cb(timestamp, probe_name, data_val) + + probe_info = self._probe_info[id_] + probe_name = probe_info['name'] + + if probe_name in self._consumers: + notify_consumers(self._consumers[probe_name], probe_name) + if '*' in self._consumers: + notify_consumers(self._consumers['*'], probe_name) + + def connect(self, hostname='localhost', port='10234'): + """Connect to xSCOPE server + + Args: + hostname (str): Hostname of running xSCOPE server. + port (str): Port number of running xSCOPE server. + + Returns: + 0 for success + 1 for failure + """ + return self.lib_xscope.xscope_ep_connect(hostname.encode(), + port.encode()) + + def disconnect(self): + """Disconnect from xSCOPE server + """ + self.lib_xscope.xscope_ep_disconnect() + + def consume(self, callback, probe_name=None): + """Consume a probe by name. + + Note: + Set probe=None to consume all probes. + + Args: + callback (callable): Callback function with signature (timestamp, probe, value). + probe_name (str): Probe name + """ + probe_name = probe_name or '*' + self._consumers[probe_name].add(callback) + + def publish(self, data): + """Publish message to endpoint. + + The length of data must be <= 255. + + Args: + data: Bytes to publish. + + Returns: + 0 for success + 1 for failure + """ + return self.lib_xscope.xscope_ep_request_upload(ctypes.c_uint(len(data)+1), ctypes.c_char_p(data)) + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser('Python xSCOPE') + parser.add_argument('--host', default='localhost', help='Hostname') + parser.add_argument('--port', default='10234', help='Port') + parser.add_argument('-c', '--consume', nargs='?', action='append', default=[], help='Probe names to consume (omit to consume all)') + parser.add_argument('-p', '--publish', default=None, help='Message to publish') + args = parser.parse_args() + + def test_callback(timestamp, probe_name, value): + print('{} {} {}'.format(timestamp, probe_name, value)) + + ep = Endpoint() + try: + if ep.connect(args.host, args.port): + print("Failed to connect") + sys.exit(1) + + if args.publish: + ep.publish(args.publish) + + if args.consume: + for probe in args.consume: + ep.consume(test_callback, probe) + else: + ep.consume(test_callback) + + while(True): + # Release the CPU + time.sleep(1) + except KeyboardInterrupt: + ep.disconnect() + + +class QueueConsumer(object): + + def __init__(self, ep, probe, /, probe_timeout=10.0): + self.ep = ep + self.probe_timeout = probe_timeout + self.ep.consume(self._consume, probe) + self.queue = queue.Queue() + + def _consume(self, timestamp, probe_name, value): + self.queue.put(value) + + def next(self, count=1): + # If the queue Empty exception is raised from here it's because the probes + # timed out when trying to get values from xscope. At least in some + # scenarios (pytest on my machine), ctrl-c fails to interrupt the script and + # just hangs forever if it's blocking on queue.get(). The timeout is + # currently serving as a watchdog so that the pytest process doesn't need + # to be killed through extraordinary means. + if count == 1: + return self.queue.get(timeout=self.probe_timeout) + + r = [] + for _ in range(count): + r.append( self.queue.get(timeout=self.probe_timeout) ) + return r + diff --git a/script/stage1.py b/script/stage1.py new file mode 100644 index 00000000..1219bd7e --- /dev/null +++ b/script/stage1.py @@ -0,0 +1,60 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import pickle as pkl +import numpy as np +from util import * +import random +import matplotlib.pyplot as plt + +import filters + + +coef_file = "coef/32_6_257_65.pkl" + +stage1, _ = filters.load(coef_file, truncate_s1=True) + + +# To make sure we did this right, let's create a random bipolar vector and see that we get the same result +if True: + pdm_signal_bytes = stage1.TapCount // 8 + pdm_signal = np.array([random.randrange(0,255) for _ in range(pdm_signal_bytes)], dtype=np.uint8) + pdm_binary = np.array(bits_array(pdm_signal), dtype=np.int) + pdm_bipolar = (2*(pdm_binary - 0.5)).astype(np.int) + + res_flt = stage1.FilterFloat(pdm_bipolar) + res_scaled = stage1.FilterInt16(pdm_bipolar) + res_bip = stage1.FilterBipolar(pdm_bipolar) + res_xcore = stage1.FilterXCore(pdm_binary) + + print(res_flt * stage1.ScaleInt16) + print(res_scaled) + print(res_bip) + print(res_xcore) + + +# # convert the transpose of the bipolar coefficient matrix into a binary coefficient matrix, where +# # -1 maps to 1 and +1 maps to 0 +# s1_coef_bin = bipolar_to_binary(s1_coef_bip.T) +# assert s1_coef_bin.shape == (16, 256) + + +# get the byte array representing the binary matrix +s1_coef_words = stage1.ToXCoreCoefArray() + +print(f"Words: {len(s1_coef_words)}") + +words = np.array(["0x%08X" % x for x in s1_coef_words], dtype=str).reshape((16,8)) + +print("{\n") + +for r in range(words.shape[0]): + print(" " + ", ".join(words[r,:]) + ", ") + + +print("\n}") + +# # Output the result +# print("{\n\n" + ", ".join([hex(x) for x in s1_coef_words]) + "\n\n}") + + diff --git a/script/stage2.py b/script/stage2.py new file mode 100644 index 00000000..3b7aa0d5 --- /dev/null +++ b/script/stage2.py @@ -0,0 +1,20 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import pickle as pkl +import numpy as np +import filters + + +coef_file = "coef/32_6_257_65.pkl" + +_, stage2 = filters.load(coef_file, truncate_s1=True) + + +print(f"Scale: {stage2.ScaleInt32}") + +print(f"Right-shift: {stage2.ShrInt32}") + + +print("\n") +print("{" + ", ".join( [f"{x}" for x in stage2.CoefInt32] ) + "}") \ No newline at end of file diff --git a/settings.json b/settings.json new file mode 100644 index 00000000..da916cb0 --- /dev/null +++ b/settings.json @@ -0,0 +1,5 @@ +{ + "title": "Mic Array Library", + "project": "lib_mic_array", + "version": "5.0.2" +} diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 00000000..82577599 --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,22 @@ + + +## Some of the test applications require the Unity test framework +CPMAddPackage( + NAME unity + GIT_REPOSITORY https://github.com/ThrowTheSwitch/Unity.git + GIT_TAG v2.5.2 + GIT_SHALLOW TRUE + DOWNLOAD_ONLY TRUE +) + +add_custom_target( tests ) + + +# The CMakeLists that comes with the Unity repo isn't suitable for our needs. +add_subdirectory( ../cmake/unity ${unity_BINARY_DIR} ) + +add_subdirectory( building ) +add_subdirectory( unit ) +add_subdirectory( signal ) +add_subdirectory( legacy ) +add_subdirectory( legacy_vanilla ) \ No newline at end of file diff --git a/tests/README.rst b/tests/README.rst new file mode 100644 index 00000000..209e2bda --- /dev/null +++ b/tests/README.rst @@ -0,0 +1,54 @@ + +tests +===== + +This directory contains the tests for ``lib_mic_array``. + +* `building`_ - Tests which ensure the various C++ class templates build correctly. +* ``etc/`` - (No tests) Contains assorted bits neededed by some test applications. +* `signal`_ - ``pytest``-based functional tests which verify mic array signal + processing +* `unit`_ - Unit tests for individual components. + +Test CMake Targets +------------------ + +Many individual CMake targets are generated for the test applications. For some +(Unity-based tests), a single binary contains many test cases. For others +(pytest-based tests) several binaries are used for single tests. + +The CMake target ``tests`` includes all test binaries. Likewise, the CMake +targets ``tests-build``, ``tests-signal`` and ``tests-unit`` include their +respective subsets of test cases. + +Building tests +-------------- + +With your CMake project properly configured, to build all test binaries, +navigate to your CMake build directory and use the following command: + +:: + + make tests + + +Running tests +------------- + +Each group of tests is run differently. + +For the tests associated with the ``tests-build`` CMake target, building the +targets is itself the test. It ensures that there are no syntax or other errors +in the C++ class templates defined in the library (because no actual +implementation of the template is generated until an application uses it). + +The test cases associated with the ``tests-unit`` CMake target use the Unity +unit test framework. The compiled binaries are stand-alone test applications +that can be run using ``xrun``. + +The test cases associated with the ``tests-signal`` CMake target use the +``pytest`` framework. See `signal`_ for more information. + +.. _building: building/ +.. _signal: signal/ +.. _unit: unit/ \ No newline at end of file diff --git a/tests/building/CMakeLists.txt b/tests/building/CMakeLists.txt new file mode 100644 index 00000000..93270741 --- /dev/null +++ b/tests/building/CMakeLists.txt @@ -0,0 +1,9 @@ + +add_custom_target( tests-build ) + +add_subdirectory( prefab ) +add_subdirectory( vanilla ) + + + +add_dependencies( tests tests-build ) \ No newline at end of file diff --git a/tests/building/README.rst b/tests/building/README.rst new file mode 100644 index 00000000..80b62a8c --- /dev/null +++ b/tests/building/README.rst @@ -0,0 +1,36 @@ + +tests-build +=========== + +Tests in this directory are meant to ensure that the mic array code will +correctly build with various configurations. This is necessary because this +library makes use of C++ class templates, which are not instantiated until used +in an application. + +* `vanilla`_ - Build tests using the vanilla API +* `prefab`_ - Build tests using the prefab API + + +Build Targets +------------- + +For these tests, building the targets is most of the test. + +To build all ``tests-build`` test cases, (with your CMake project properly +configured) navigate to your CMake build directory and use the following +command: + +:: + + make tests-build + +To build only the ``vanilla`` or ``prefab`` targets, use ``tests-build-vanilla`` and ``tests-build-prefab`` respectively. + + +Running Test Apps +----------------- + +The generated binaries can be run with ``xrun`` to verify that no run-time exceptions happen during initialization or steady-state operation. + +.. _vanilla: vanilla/ +.. _prefab: prefab/ \ No newline at end of file diff --git a/tests/building/prefab/CMakeLists.txt b/tests/building/prefab/CMakeLists.txt new file mode 100644 index 00000000..be473f7d --- /dev/null +++ b/tests/building/prefab/CMakeLists.txt @@ -0,0 +1,45 @@ + +set( APP_NAME tests-build-prefab ) + +set( TARGET_XN XVF3610_Q60A.xn ) + + +set(APP_COMPILE_FLAGS + "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_XN}" + "-fxscope" + "-mcmodel=large" + "-Wno-xcore-fptrgroup" + "-Wno-unknown-pragmas" + "-report" + "-g" + "-O2" +) + +set(APP_LINK_FLAGS ${APP_COMPILE_FLAGS} ) + +set( APP_INCLUDES "src" ) + +set( APP_SOURCES + "src/app.cpp" + "src/main.xc" ) + +add_executable( ${APP_NAME} ) + +target_compile_options( ${APP_NAME} +PRIVATE ${APP_COMPILE_FLAGS} ) + +target_link_options( ${APP_NAME} +PRIVATE ${APP_LINK_FLAGS} ) + +target_sources( ${APP_NAME} +PRIVATE ${APP_SOURCES} ) + +target_include_directories( ${APP_NAME} +PRIVATE ${APP_INCLUDES} ) + +target_link_libraries( ${APP_NAME} + lib_xcore_math + lib_mic_array ) + + +add_dependencies( tests-build tests-build-prefab ) \ No newline at end of file diff --git a/tests/building/prefab/README.rst b/tests/building/prefab/README.rst new file mode 100644 index 00000000..fce5316c --- /dev/null +++ b/tests/building/prefab/README.rst @@ -0,0 +1,37 @@ + +tests-build-prefab +================== + +This directory contains build tests for the prefab API. + +These tests are intended only to ensure: + +* ``MicArray`` class templates derived from the prefab API can build correctly + (with various configurations) in an actual application +* Mic Array unit can be started and actually deliver frames of audio. + +> Note: The contents of delivered audio frames are ignored. + +Build Targets +------------- + +A single target, called `tests-build-prefab`, is defined for this test. + +To build, (with your CMake project properly configured) navigate to your CMake +build directory and use the following command: + +:: + + make tests-build-prefab + + +Configurations Tested +--------------------- + +This test currently builds an application which instantiates the +``mic_array::prefab::BasicMicArray<>`` class template using combinations of each +of the following parameters and values: + +* Mic Count: 1, 2 +* Frame Size: 1, 16, 256 +* DC Offset Elimination: disabled, enabled \ No newline at end of file diff --git a/tests/building/prefab/XVF3610_Q60A.xn b/tests/building/prefab/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/tests/building/prefab/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/building/prefab/src/app.cpp b/tests/building/prefab/src/app.cpp new file mode 100644 index 00000000..33bb8dd7 --- /dev/null +++ b/tests/building/prefab/src/app.cpp @@ -0,0 +1,202 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "app.h" + +#include "mic_array/cpp/Prefab.hpp" + +#define APP_AUDIO_CLOCK_FREQUENCY 24576000 +#define APP_PDM_CLOCK_FREQUENCY 3072000 + +pdm_rx_resources_t pdm_res_sdr = + PDM_RX_RESOURCES_SDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + XS1_CLKBLK_1); + +pdm_rx_resources_t pdm_res_ddr = + PDM_RX_RESOURCES_DDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + XS1_CLKBLK_1, + XS1_CLKBLK_2); + +using namespace mic_array::prefab; + + +BasicMicArray<1, 1, false> mics_1_1_false; +BasicMicArray<1, 1, true> mics_1_1_true; +BasicMicArray<1, 16, false> mics_1_16_false; +BasicMicArray<1, 16, true> mics_1_16_true; +BasicMicArray<1, 256, false> mics_1_256_false; +BasicMicArray<1, 256, true> mics_1_256_true; + +BasicMicArray<2, 1, false> mics_2_1_false; +BasicMicArray<2, 1, true> mics_2_1_true; +BasicMicArray<2, 16, false> mics_2_16_false; +BasicMicArray<2, 16, true> mics_2_16_true; +BasicMicArray<2, 256, false> mics_2_256_false; +BasicMicArray<2, 256, true> mics_2_256_true; + + + + +#define mics_call(ACTION) do { \ + if(mic_count == 1){ \ + if(use_dcoe){ \ + if(frame_size == 1) { \ + mics_1_1_true.ACTION; \ + } else if(frame_size == 16) { \ + mics_1_16_true.ACTION; \ + } else { \ + mics_1_256_true.ACTION; \ + } \ + } else { \ + if(frame_size == 1) { \ + mics_1_1_false.ACTION; \ + } else if(frame_size == 16) { \ + mics_1_16_false.ACTION; \ + } else { \ + mics_1_256_false.ACTION; \ + } \ + } \ + } else { \ + if(use_dcoe){ \ + if(frame_size == 1) { \ + mics_2_1_true.ACTION; \ + } else if(frame_size == 16) { \ + mics_2_16_true.ACTION; \ + } else { \ + mics_2_256_true.ACTION; \ + } \ + } else { \ + if(frame_size == 1) { \ + mics_2_1_false.ACTION; \ + } else if(frame_size == 16) { \ + mics_2_16_false.ACTION; \ + } else { \ + mics_2_256_false.ACTION; \ + } \ + } \ + } } while(0) + + + + +// The parameters of these functions prevents any of the +// `BasicMicArray` instances from being optimized out +MA_C_API +void app_init( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe) +{ + assert(mic_count == 1 || mic_count == 2); + assert(frame_size == 1 || frame_size == 16 || frame_size == 256); + + const unsigned mclk_div = mic_array_mclk_divider( + APP_AUDIO_CLOCK_FREQUENCY, APP_PDM_CLOCK_FREQUENCY); + + + mics_1_1_true.Init(); + mics_1_16_true.Init(); + mics_1_256_true.Init(); + mics_1_1_false.Init(); + mics_1_16_false.Init(); + mics_1_256_false.Init(); + + mics_2_1_true.Init(); + mics_2_16_true.Init(); + mics_2_256_true.Init(); + mics_2_1_false.Init(); + mics_2_16_false.Init(); + mics_2_256_false.Init(); + + // No harm in setting the port on all of them. + mics_1_1_true.SetPort(pdm_res_sdr.p_pdm_mics); + mics_1_16_true.SetPort(pdm_res_sdr.p_pdm_mics); + mics_1_256_true.SetPort(pdm_res_sdr.p_pdm_mics); + mics_1_1_false.SetPort(pdm_res_sdr.p_pdm_mics); + mics_1_16_false.SetPort(pdm_res_sdr.p_pdm_mics); + mics_1_256_false.SetPort(pdm_res_sdr.p_pdm_mics); + + mics_2_1_true.SetPort(pdm_res_ddr.p_pdm_mics); + mics_2_16_true.SetPort(pdm_res_ddr.p_pdm_mics); + mics_2_256_true.SetPort(pdm_res_ddr.p_pdm_mics); + mics_2_1_false.SetPort(pdm_res_ddr.p_pdm_mics); + mics_2_16_false.SetPort(pdm_res_ddr.p_pdm_mics); + mics_2_256_false.SetPort(pdm_res_ddr.p_pdm_mics); + + if(mic_count == 1) + mic_array_resources_configure(&pdm_res_sdr, mclk_div); + else + mic_array_resources_configure(&pdm_res_ddr, mclk_div); +} + +// If pdm_rx is to be run as a thread +MA_C_API +void app_pdm_rx_task( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe) +{ + assert(mic_count == 1 || mic_count == 2); + assert(frame_size == 1 || frame_size == 16 || frame_size == 256); + + if(mic_count == 1) + mic_array_pdm_clock_start(&pdm_res_sdr); + else + mic_array_pdm_clock_start(&pdm_res_ddr); + + mics_call(PdmRxThreadEntry()); +} + + +MA_C_API +void app_setup_pdm_rx_isr( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe) +{ + assert(mic_count == 1 || mic_count == 2); + assert(frame_size == 1 || frame_size == 16 || frame_size == 256); + + if(mic_count == 1) + mic_array_pdm_clock_start(&pdm_res_sdr); + else + mic_array_pdm_clock_start(&pdm_res_ddr); + + mics_call(InstallPdmRxISR()); + mics_call(UnmaskPdmRxISR()); +} + + +MA_C_API +void app_decimator_task( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe, + chanend_t c_audio_frames) +{ + assert(mic_count == 1 || mic_count == 2); + assert(frame_size == 1 || frame_size == 16 || frame_size == 256); + + // No harm in setting the channel on all of them. + mics_1_1_true.SetOutputChannel(c_audio_frames); + mics_1_16_true.SetOutputChannel(c_audio_frames); + mics_1_256_true.SetOutputChannel(c_audio_frames); + mics_1_1_false.SetOutputChannel(c_audio_frames); + mics_1_16_false.SetOutputChannel(c_audio_frames); + mics_1_256_false.SetOutputChannel(c_audio_frames); + + mics_2_1_true.SetOutputChannel(c_audio_frames); + mics_2_16_true.SetOutputChannel(c_audio_frames); + mics_2_256_true.SetOutputChannel(c_audio_frames); + mics_2_1_false.SetOutputChannel(c_audio_frames); + mics_2_16_false.SetOutputChannel(c_audio_frames); + mics_2_256_false.SetOutputChannel(c_audio_frames); + + mics_call(ThreadEntry()); +} \ No newline at end of file diff --git a/tests/building/prefab/src/app.h b/tests/building/prefab/src/app.h new file mode 100644 index 00000000..2879c2b0 --- /dev/null +++ b/tests/building/prefab/src/app.h @@ -0,0 +1,36 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "mic_array.h" + +C_API_START + + +MA_C_API +void app_init( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe); + +MA_C_API +void app_pdm_rx_task( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe); + +MA_C_API +void app_setup_pdm_rx_isr( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe); + +MA_C_API +void app_decimator_task( + unsigned mic_count, + unsigned frame_size, + unsigned use_dcoe, + chanend_t c_audio_frames); + +C_API_END \ No newline at end of file diff --git a/tests/building/prefab/src/main.xc b/tests/building/prefab/src/main.xc new file mode 100644 index 00000000..ece76da4 --- /dev/null +++ b/tests/building/prefab/src/main.xc @@ -0,0 +1,113 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "mic_array/frame_transfer.h" + +#include "app.h" + +#include +#include +#include +#include + +#include +#include +#include + +#define MIC_COUNT 2 +#define FRAME_SIZE 256 +#define USE_DCOE 1 +#define PDM_RX_AS_ISR 1 + +unsafe { + +// Consumes audio to prevent mic array from backing up. +void eat_frames(chanend c_frames_in) +{ + int32_t frame_buff[MIC_COUNT][FRAME_SIZE]; + unsigned frame_count = 0; + + while(1){ + ma_frame_rx(&frame_buff[0][0], (chanend_t)c_frames_in, + MIC_COUNT, FRAME_SIZE); + if(frame_count % 1 == 0) + printf("Frame count: %u\n", frame_count); + frame_count++; + } +} + + +#define DEVICE_PLL_CTL_VAL 0x0A019803 // Valid for all + // fractional values +#define DEVICE_PLL_FRAC_NOM 0x800095F9 // 24.576000 MHz + +void device_pll_init() +{ + unsigned tileid = get_local_tile_id(); + + const unsigned DEVICE_PLL_DISABLE = 0x0201FF04; + const unsigned DEVICE_PLL_DIV_0 = 0x80000004; + + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_DISABLE); + + delay_milliseconds(1); + + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_CTL_VAL); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_CTL_VAL); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_FRAC_N_DIVIDER_NUM, + DEVICE_PLL_FRAC_NOM); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_CLK_DIVIDER_NUM, + DEVICE_PLL_DIV_0); +} + + + + +int main() { + par { + on tile[1]: { + chan c_audio_frames; + + xscope_config_io(XSCOPE_IO_BASIC); + + // Set up the media clock to 24.576 MHz + device_pll_init(); + + // Initialize mic array + app_init(MIC_COUNT, FRAME_SIZE, USE_DCOE); + + par { + // Launch mic array thread + { + if(PDM_RX_AS_ISR){ + app_setup_pdm_rx_isr(MIC_COUNT, FRAME_SIZE, USE_DCOE); + } + + app_decimator_task(MIC_COUNT, FRAME_SIZE, USE_DCOE, + (chanend_t) c_audio_frames); + } + + // If running Pdm Rx as a thread, run it + { + if(! PDM_RX_AS_ISR){ + app_pdm_rx_task(MIC_COUNT, FRAME_SIZE, USE_DCOE); + } + } + + // Consume frames + eat_frames(c_audio_frames); + } + } + } + + return 0; +} + +} diff --git a/tests/building/vanilla/CMakeLists.txt b/tests/building/vanilla/CMakeLists.txt new file mode 100644 index 00000000..fcb58f6c --- /dev/null +++ b/tests/building/vanilla/CMakeLists.txt @@ -0,0 +1,81 @@ + +set( APP_NAME tests-build-vanilla ) + +set( TARGET_XN XVF3610_Q60A.xn ) + +set( MCLK_FREQ 24576000 ) + + +set(APP_COMPILE_FLAGS + "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_XN}" + "-fxscope" + "-mcmodel=large" + "-Wno-xcore-fptrgroup" + "-Wno-unknown-pragmas" + "-report" + "-g" + "-O2" +) + +set(APP_LINK_FLAGS ${APP_COMPILE_FLAGS} ) + +set( APP_INCLUDES "src" ) + +set( APP_SOURCES "src/main.xc" ) + +#********************** +# create targets +#********************** + +# Things to vary: +# MIC_COUNT -> 1, 2 +# FRAME_SIZE -> 1, 16, 256 +# PDM_FREQ -> 3.072 MHz (16kHz audio), 6.144 MHz (24kHz audio) +# DCOE_ENABLED -> false, true + +add_custom_target( ${APP_NAME} ) + +foreach( MIC_COUNT 1 2 ) + foreach( FRAME_SIZE 1 16 256 ) + foreach( PDM_FREQ 3072000 6144000 ) + foreach( DCOE_ENABLED 0 1 ) + + set( TARG_NAME "${APP_NAME}_${MIC_COUNT}mic_${FRAME_SIZE}spf_${PDM_FREQ}hz" ) + if( ${DCOE_ENABLED} ) + set( TARG_NAME "${TARG_NAME}_dcoe" ) + endif() + + add_executable( ${TARG_NAME} ) + + target_compile_options( ${TARG_NAME} + PRIVATE ${APP_COMPILE_FLAGS} ) + + target_link_options( ${TARG_NAME} + PRIVATE ${APP_LINK_FLAGS} ) + + target_sources( ${TARG_NAME} + PRIVATE ${APP_SOURCES} ) + + target_include_directories( ${TARG_NAME} + PRIVATE ${APP_INCLUDES} ) + + target_link_libraries( ${TARG_NAME} + lib_xcore_math + lib_mic_array ) + + target_compile_definitions( ${TARG_NAME} + PRIVATE MIC_ARRAY_CONFIG_USE_DC_ELIMINATION=${DCOE_ENABLED} ) + + mic_array_vanilla_add( ${TARG_NAME} + ${MCLK_FREQ} ${PDM_FREQ} + ${MIC_COUNT} ${FRAME_SIZE} ) + + add_dependencies( ${APP_NAME} ${TARG_NAME} ) + + endforeach() + endforeach() + endforeach() +endforeach() + + +add_dependencies( tests-build tests-build-vanilla ) \ No newline at end of file diff --git a/tests/building/vanilla/README.rst b/tests/building/vanilla/README.rst new file mode 100644 index 00000000..35608e6b --- /dev/null +++ b/tests/building/vanilla/README.rst @@ -0,0 +1,41 @@ + +tests-build-vanilla +=================== + +This directory contains build tests for the vanilla API. + +These tests are intended only to ensure: + +* ``MicArray`` class templates using the vanilla API can build correctly (with + various configurations) in an actual application +* Mic Array unit can be started and actually deliver frames of audio. + +> Note: The contents of delivered audio frames are ignored. + +### Build Targets + +Because the vanilla API uses preprocessor definitions to specify the build +parameters, a separate target with different preprocessor defintions is +generated for each test configuration. + +A custom target, called `tests-build-vanilla`, is defined which builds each +generated test target. + +To build, (with your CMake project properly configured) navigate to your CMake +build directory and use the following command: + +:: + + make tests-build-vanilla + + +Configurations Tested +--------------------- + +This test currently builds an application using the vanilla API which varies +each of the following parameters and values: + +* Mic Count: 1, 2 +* Frame Size: 1, 16, 256 +* PDM Freq: 3.072 MHz, 6.144 MHz +* DC Offset Elimination: disabled, enabled \ No newline at end of file diff --git a/tests/building/vanilla/XVF3610_Q60A.xn b/tests/building/vanilla/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/tests/building/vanilla/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/building/vanilla/src/main.xc b/tests/building/vanilla/src/main.xc new file mode 100644 index 00000000..16d73208 --- /dev/null +++ b/tests/building/vanilla/src/main.xc @@ -0,0 +1,98 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "mic_array_vanilla.h" +#include "mic_array/frame_transfer.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#define MIC_COUNT MIC_ARRAY_CONFIG_MIC_COUNT +#define FRAME_SIZE MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME + +unsafe { + +// Consumes audio to prevent mic array from backing up. +void eat_frames(chanend c_frames_in) +{ + int32_t frame_buff[MIC_COUNT][FRAME_SIZE]; + unsigned frame_count = 0; + + while(1){ + ma_frame_rx(&frame_buff[0][0], (chanend_t)c_frames_in, + MIC_COUNT, FRAME_SIZE); + if(frame_count % 1 == 0) + printf("Frame count: %u\n", frame_count); + frame_count++; + } +} + + +#define DEVICE_PLL_CTL_VAL 0x0A019803 // Valid for all + // fractional values +#define DEVICE_PLL_FRAC_NOM 0x800095F9 // 24.576000 MHz + +void device_pll_init() +{ + unsigned tileid = get_local_tile_id(); + + const unsigned DEVICE_PLL_DISABLE = 0x0201FF04; + const unsigned DEVICE_PLL_DIV_0 = 0x80000004; + + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_DISABLE); + + delay_milliseconds(1); + + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_CTL_VAL); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_CTL_NUM, + DEVICE_PLL_CTL_VAL); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_PLL_FRAC_N_DIVIDER_NUM, + DEVICE_PLL_FRAC_NOM); + write_sswitch_reg(tileid, + XS1_SSWITCH_SS_APP_CLK_DIVIDER_NUM, + DEVICE_PLL_DIV_0); +} + + + + +int main() { + par { + on tile[1]: { + chan c_audio_frames; + + xscope_config_io(XSCOPE_IO_BASIC); + + // Set up the media clock to 24.576 MHz + device_pll_init(); + + // Initialize mic array + ma_vanilla_init(); + + par { + // Launch mic array thread + ma_vanilla_task((chanend_t) c_audio_frames); + + // Consume frames + eat_frames(c_audio_frames); + } + } + } + + return 0; +} + +} diff --git a/tests/legacy/CMakeLists.txt b/tests/legacy/CMakeLists.txt new file mode 100644 index 00000000..53f01c68 --- /dev/null +++ b/tests/legacy/CMakeLists.txt @@ -0,0 +1,18 @@ + +set(BINARY_PATH bin) +set(BINARY_NAME legacy_build.xe) + +set(LEGACY_BUILD_TOOL xmake) + +# This folder is for making sure that the module_build_info in the +# library is correct. Not an app that needs to be run, just built. +# Here it's added as a custom target so that it can be tested just +# via CMake +add_custom_target( tests-legacy_build + BYPRODUCTS ${BINARY_PATH}/${BINARY_NAME} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ${LEGACY_BUILD_TOOL} + COMMENT "Building legacy_build.xe..." ) + + +add_dependencies( tests tests-legacy_build ) \ No newline at end of file diff --git a/legacy_tests/test_mic_dual/Makefile b/tests/legacy/Makefile similarity index 50% rename from legacy_tests/test_mic_dual/Makefile rename to tests/legacy/Makefile index 769c0bf8..53d46140 100644 --- a/legacy_tests/test_mic_dual/Makefile +++ b/tests/legacy/Makefile @@ -1,29 +1,41 @@ # The TARGET variable determines what target system the application is # compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER +# or a valid argument for the --target option when compiling. + +TARGET = XVF3610_Q60A.xn # The APP_NAME variable determines the name of the final .xe file. It should # not include the .xe postfix. If left blank the name will default to # the project name -APP_NAME = -# The USED_MODULES variable lists other module used by the application. -USED_MODULES = lib_mic_array +APP_NAME = legacy_build + +SOURCE_DIRS = src + # The flags passed to xcc when building the application # You can also set the following to override flags for a particular language: -# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS +# +# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS +# # If the variable XCC_MAP_FLAGS is set it overrides the flags passed to # xcc for the final link (mapping) stage. -XCC_FLAGS = -O2 -g +XCC_FLAGS = -fxscope -g -mcmodel=large \ + -report -Os \ + -DAPP_NAME=\"demo_2mic_isr\" \ + -DN_MICS=2 \ + -DAPP_USE_PDM_RX_ISR=1 -# The XCORE_ARM_PROJECT variable, if set to 1, configures this -# project to create both xCORE and ARM binaries. -XCORE_ARM_PROJECT = 0 +XCC_CPP_FLAGS = $(XCC_FLAGS) -std=c++11 -SOURCE_DIRS = src +# The USED_MODULES variable lists other module used by the application. + +USED_MODULES = lib_mic_array + +#============================================================================= +# The following part of the Makefile includes the common build infrastructure +# for compiling XMOS applications. You should not need to edit below here. XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common +include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common \ No newline at end of file diff --git a/tests/legacy/src/XVF3610_Q60A.xn b/tests/legacy/src/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/tests/legacy/src/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/legacy/src/app.cpp b/tests/legacy/src/app.cpp new file mode 100644 index 00000000..3d34cc03 --- /dev/null +++ b/tests/legacy/src/app.cpp @@ -0,0 +1,64 @@ + + +#include "mic_array.h" +#include "mic_array/cpp/Prefab.hpp" +#include "app.h" + + +#if (N_MICS != 2) +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_SDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + MIC_ARRAY_CLK1); +#else +pdm_rx_resources_t pdm_res = PDM_RX_RESOURCES_DDR( + PORT_MCLK_IN_OUT, + PORT_PDM_CLK, + PORT_PDM_DATA, + MIC_ARRAY_CLK1, + MIC_ARRAY_CLK2); +#endif + + +using TMicArray = mic_array::prefab::BasicMicArray< + N_MICS, SAMPLES_PER_FRAME, DCOE_ENABLED>; + +TMicArray mics = TMicArray(); + +MA_C_API +void app_init() +{ + mics.Init(); + + // Configure our clocks and ports + const unsigned mclk_div = mic_array_mclk_divider( + APP_AUDIO_CLOCK_FREQUENCY, APP_PDM_CLOCK_FREQUENCY); + + mic_array_resources_configure(&pdm_res, mclk_div); + + mics.PdmRx.Init(pdm_res.p_pdm_mics); +} + +MA_C_API +void app_pdm_rx_task() +{ + mic_array_pdm_clock_start(&pdm_res); + mics.PdmRxThreadEntry(); +} + +MA_C_API +void app_decimator_task(chanend_t c_audio_frames) +{ + mics.SetOutputChannel(c_audio_frames); + +#if APP_USE_PDM_RX_ISR + // Start the PDM clock + mic_array_pdm_clock_start(&pdm_res); + + mics.InstallPdmRxISR(); + mics.UnmaskPdmRxISR(); +#endif + + mics.ThreadEntry(); +} diff --git a/tests/legacy/src/app.h b/tests/legacy/src/app.h new file mode 100644 index 00000000..c6136e12 --- /dev/null +++ b/tests/legacy/src/app.h @@ -0,0 +1,39 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "mic_array.h" + +#define SAMPLES_PER_FRAME 16 +#define AUDIO_BUFFER_SAMPLES ((unsigned) (SAMPLES_PER_FRAME * 1.2f + 4)) +#define APP_AUDIO_CLOCK_FREQUENCY 24576000 +#define APP_PDM_CLOCK_FREQUENCY 3072000 +#define APP_AUDIO_PIPELINE_SAMPLE_RATE 16000 +#define MIC_ARRAY_CLK1 XS1_CLKBLK_1 +#define MIC_ARRAY_CLK2 XS1_CLKBLK_2 +#define DCOE_ENABLED true + + +C_API_START + +/** + * @brief Application-specific intitialization + */ +MA_C_API +void app_init(); + +/** + * @brief C-compatible wrapper for PDM rx thread entry point + */ +MA_C_API +void app_pdm_rx_task(); + +/** + * @brief + */ +MA_C_API +void app_decimator_task(chanend_t c_audio_frames); + + +C_API_END \ No newline at end of file diff --git a/tests/legacy/src/main.xc b/tests/legacy/src/main.xc new file mode 100644 index 00000000..f4fa7306 --- /dev/null +++ b/tests/legacy/src/main.xc @@ -0,0 +1,41 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "app.h" + +///////////////////////////////////////////////////////////////////////////// +// WARNING: This is just a test app to make sure the library's +// module_build_info is correct. This app doesn't actually do +// anything at the moment. +///////////////////////////////////////////////////////////////////////////// + +unsafe{ + +int main() { + chan c_audio_frames; + par { + on tile[0]: { + xscope_config_io(XSCOPE_IO_BASIC); + } + on tile[1]: { + xscope_config_io(XSCOPE_IO_BASIC); + app_init(); + par { app_decimator_task((chanend_t) c_audio_frames); } + } + } + + return 0; +} + +} diff --git a/tests/legacy_vanilla/CMakeLists.txt b/tests/legacy_vanilla/CMakeLists.txt new file mode 100644 index 00000000..6cbd2e6d --- /dev/null +++ b/tests/legacy_vanilla/CMakeLists.txt @@ -0,0 +1,18 @@ + +set(BINARY_PATH bin) +set(BINARY_NAME legacy_build_vanilla.xe) + +set(LEGACY_BUILD_TOOL xmake) + +# This folder is for making sure that the module_build_info in the +# library is correct. Not an app that needs to be run, just built. +# Here it's added as a custom target so that it can be tested just +# via CMake +add_custom_target( tests-legacy_build_vanilla + BYPRODUCTS ${BINARY_PATH}/${BINARY_NAME} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ${LEGACY_BUILD_TOOL} + COMMENT "Building legacy_build_vanilla.xe..." ) + + +add_dependencies( tests tests-legacy_build_vanilla ) \ No newline at end of file diff --git a/tests/legacy_vanilla/Makefile b/tests/legacy_vanilla/Makefile new file mode 100644 index 00000000..63a8a3b9 --- /dev/null +++ b/tests/legacy_vanilla/Makefile @@ -0,0 +1,44 @@ +# The TARGET variable determines what target system the application is +# compiled for. It either refers to an XN file in the source directories +# or a valid argument for the --target option when compiling. + +TARGET = XVF3610_Q60A.xn + +# The APP_NAME variable determines the name of the final .xe file. It should +# not include the .xe postfix. If left blank the name will default to +# the project name + +APP_NAME = legacy_build_vanilla + +VANILLA_API_ENABLED=1 + +SOURCE_DIRS = src + + +# The flags passed to xcc when building the application +# You can also set the following to override flags for a particular language: +# +# XCC_XC_FLAGS, XCC_C_FLAGS, XCC_ASM_FLAGS, XCC_CPP_FLAGS +# +# If the variable XCC_MAP_FLAGS is set it overrides the flags passed to +# xcc for the final link (mapping) stage. + +XCC_FLAGS = -fxscope -g -mcmodel=large \ + -report -Os \ + -DMIC_ARRAY_CONFIG_MCLK_FREQ=24576000 \ + -DMIC_ARRAY_CONFIG_PDM_FREQ=3072000 \ + -DMIC_ARRAY_CONFIG_MIC_COUNT=2 \ + -DMIC_ARRAY_CONFIG_SAMPLES_PER_FRAME=16 + +XCC_CPP_FLAGS = $(XCC_FLAGS) -std=c++11 + +# The USED_MODULES variable lists other module used by the application. + +USED_MODULES = lib_mic_array + +#============================================================================= +# The following part of the Makefile includes the common build infrastructure +# for compiling XMOS applications. You should not need to edit below here. + +XMOS_MAKE_PATH ?= ../.. +include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common \ No newline at end of file diff --git a/tests/legacy_vanilla/src/XVF3610_Q60A.xn b/tests/legacy_vanilla/src/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/tests/legacy_vanilla/src/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/legacy_vanilla/src/main.xc b/tests/legacy_vanilla/src/main.xc new file mode 100644 index 00000000..d7f8e953 --- /dev/null +++ b/tests/legacy_vanilla/src/main.xc @@ -0,0 +1,42 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "mic_array.h" +#include "mic_array_vanilla.h" + +///////////////////////////////////////////////////////////////////////////// +// WARNING: This is just a test app to make sure the library's +// module_build_info is correct. This app doesn't actually do +// anything at the moment. +///////////////////////////////////////////////////////////////////////////// + +unsafe{ + +int main() { + chan c_audio_frames; + par { + on tile[0]: { + xscope_config_io(XSCOPE_IO_BASIC); + } + on tile[1]: { + xscope_config_io(XSCOPE_IO_BASIC); + ma_vanilla_init(); + par { ma_vanilla_task((chanend_t) c_audio_frames); } + } + } + + return 0; +} + +} diff --git a/tests/signal/BasicMicArray/CMakeLists.txt b/tests/signal/BasicMicArray/CMakeLists.txt new file mode 100644 index 00000000..e6258e62 --- /dev/null +++ b/tests/signal/BasicMicArray/CMakeLists.txt @@ -0,0 +1,84 @@ + +set( APP_NAME tests-signal-basicmicarray ) + +set( TARGET_XN XVF3610_Q60A.xn ) + +add_custom_target( ${APP_NAME} ) +add_dependencies( tests-signal ${APP_NAME} ) + +get_filename_component(XSCOPE_CONFIG config.xscope ABSOLUTE) + +set(APP_COMPILE_FLAGS + "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_XN}" + "${XSCOPE_CONFIG}" + "-fxscope" + "-mcmodel=large" + "-Wno-xcore-fptrgroup" + "-Wno-unknown-pragmas" + "-Wno-format" + "-g" + "-O2" +) + +set(APP_LINK_FLAGS ${APP_COMPILE_FLAGS} ) +list( APPEND APP_LINK_FLAGS "-report" ) + +set( APP_INCLUDES "src" ) + +file( GLOB_RECURSE APP_SOURCES + "src/*.c" + "src/*.xc" + "src/*.cpp" ) + +macro( create_target MICS FRAME_SIZE USE_ISR ) + + set( TARG_NAME "${APP_NAME}_${MICS}ch_${FRAME_SIZE}smp_${USE_ISR}" ) + + add_executable( ${TARG_NAME} ) + + target_compile_options( ${TARG_NAME} + PRIVATE ${APP_COMPILE_FLAGS} ) + + target_link_options( ${TARG_NAME} + PRIVATE ${APP_LINK_FLAGS} ) + + target_sources( ${TARG_NAME} + PRIVATE ${APP_SOURCES} ) + + target_include_directories( ${TARG_NAME} + PRIVATE ${APP_INCLUDES} ) + + target_link_libraries( ${TARG_NAME} + lib_xcore_math + lib_mic_array ) + + target_compile_definitions( ${TARG_NAME} + PRIVATE "CHAN_COUNT=${MICS}" + "SAMPLES_PER_FRAME=${FRAME_SIZE}" + "USE_ISR=${USE_ISR}" + ) + + add_dependencies( ${APP_NAME} ${TARG_NAME} ) +endmacro() + + +# Application parameters +# Mics Frame Size ISR +create_target( 1 1 0 ) +create_target( 1 16 0 ) +create_target( 2 1 0 ) +create_target( 2 16 0 ) +create_target( 4 1 0 ) +create_target( 4 16 0 ) +create_target( 8 1 0 ) +create_target( 8 16 0 ) +create_target( 8 64 0 ) +create_target( 1 1 1 ) +create_target( 1 16 1 ) +create_target( 2 1 1 ) +create_target( 2 16 1 ) +create_target( 4 1 1 ) +create_target( 4 16 1 ) +create_target( 8 1 1 ) +create_target( 8 16 1 ) +create_target( 8 64 1 ) diff --git a/tests/signal/BasicMicArray/README.rst b/tests/signal/BasicMicArray/README.rst new file mode 100644 index 00000000..34b86e49 --- /dev/null +++ b/tests/signal/BasicMicArray/README.rst @@ -0,0 +1,41 @@ + +tests-signal-BasicMicArray +========================== + +Tests in this directory ensure that the signal processing performed by the +``BasicMicArray`` prefab class template behaves as expected. This exercises the +whole mic array unit from the PDM rx input to the output of the framing +component. + +Each of these scripts are run using ``pytest``, which will launch the +application in the debugger. + +* ``test_mic_array.py`` - Tests ``BasicMicArray`` in various configurations + +Build Targets +------------- + +Several CMake targets are generated, and all should be built prior to running +the test script in Pytest. + +To build all ``tests-signal-BasicMicArray`` targets, (with your CMake project +properly configured) navigate to your CMake build directory and use the +following command: + +:: + + make tests-signal-BasicMicArray + + +Running Tests +------------- + +Test cases should be run from the base of your CMake build directory. From +there, with Python3 and the XMOS XTC tools in your path, simply call pytest with +the path to the test script as the only necessary argument. For example, to run +``test_mic_array.py``: + +:: + + pytest ..\tests\signal\BasicMicArray\test_mic_array.py + diff --git a/tests/signal/BasicMicArray/XVF3610_Q60A.xn b/tests/signal/BasicMicArray/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/tests/signal/BasicMicArray/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/AN00220_app_phase_aligned_example/config.xscope b/tests/signal/BasicMicArray/config.xscope similarity index 86% rename from examples/AN00220_app_phase_aligned_example/config.xscope rename to tests/signal/BasicMicArray/config.xscope index ecf61949..76ac74fe 100644 --- a/examples/AN00220_app_phase_aligned_example/config.xscope +++ b/tests/signal/BasicMicArray/config.xscope @@ -19,8 +19,7 @@ + + - - - diff --git a/tests/signal/BasicMicArray/conftest.py b/tests/signal/BasicMicArray/conftest.py new file mode 100644 index 00000000..542d9f1f --- /dev/null +++ b/tests/signal/BasicMicArray/conftest.py @@ -0,0 +1,85 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import sys, os, pytest, enum +sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..','..',"script")) +from mic_array.case_replay import ReplayMode + + +FLAGS = [ + "save-case", + "load-case", + "print-output", + "print-xgdb", + "debug-print-filters" +] + +def pytest_addoption(parser): + parser.addoption("--build-dir", action="store", default='.') + parser.addoption("--frames", type=int, default=40) + + addflag = lambda x: parser.addoption(f"--{x}", action="store_true") + + [addflag(x) for x in FLAGS] + +# Relative to build directory +APP_BUILD_DIR = os.path.join('tests','signal','BasicMicArray') + +# Each app is prefixed with this +XE_NAME_ROOT = 'tests-signal-basicmicarray' + +# Parameters come from CMakeLists.txt. If that changes, this may also need +# to change. + +# (MICS, FRAME_SIZE, USE_ISR) +xe_params = [ + (1, 1, 0), + (1, 16, 0), + (2, 1, 0), + (2, 16, 0), + (4, 1, 0), + (4, 16, 0), + (8, 1, 0), + (8, 16, 0), + (8, 64, 0), + (1, 1, 1), + (1, 16, 1), + (2, 1, 1), + (2, 16, 1), + (4, 1, 1), + (4, 16, 1), + (8, 1, 1), + (8, 16, 1), + (8, 64, 1), +] + +test_params = [ + pytest.param((x,y,z), id=f"{x}ch_{y}smp_{z}") for x,y,z in xe_params +] + +# Get the file path given params and build_dir +def xe_file_path(params, build_dir): + xe_name = f"{XE_NAME_ROOT}_{params[0]}ch_{params[1]}smp_{params[2]}.xe" + xe_path = os.path.abspath( + os.path.join(build_dir, APP_BUILD_DIR, xe_name) + ) + return xe_path + +@pytest.fixture() +def replay_mode(request): + save = request.config.getoption("save_case") + load = request.config.getoption("load_case") + if save and load: + raise Exception("Cannot use both --save-case and --load-case options.") + mode = (ReplayMode.SAVE_VECTORS if save else + (ReplayMode.LOAD_VECTORS if load else + ReplayMode.DO_NOTHING) ) + if mode != ReplayMode.DO_NOTHING: + print(f"Using replay mode: {mode.name}") + return mode + + +class DevCommand(enum.Enum): + RESUME = 0 + TERMINATE = 1 + PRINT_FILTERS = 2 \ No newline at end of file diff --git a/tests/signal/BasicMicArray/default_filters.pkl b/tests/signal/BasicMicArray/default_filters.pkl new file mode 100644 index 00000000..f4d70147 Binary files /dev/null and b/tests/signal/BasicMicArray/default_filters.pkl differ diff --git a/tests/signal/BasicMicArray/micarray_device.py b/tests/signal/BasicMicArray/micarray_device.py new file mode 100644 index 00000000..3f3d65f7 --- /dev/null +++ b/tests/signal/BasicMicArray/micarray_device.py @@ -0,0 +1,65 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + + +import numpy as np +from mic_array.device_context import DeviceContext +from mic_array import filters +from mic_array.pdm_signal import PdmSignal + + +class MicArrayDevice(DeviceContext): + + def __init__(self, xe_path, /, **kwargs): + super().__init__(xe_path, probes=["meta_out", "data_out"], **kwargs) + + self.channels = None # unknown initially + + def next_data(self, count=1): + return self.probe_next("data_out", count=count) + + def next_meta(self, count=1): + return self.probe_next("meta_out", count=count) + + def _on_connect(self): + self.param = { + "channels": self.next_meta(), + "s1.tap_count": self.next_meta(), + "s1.dec_factor": self.next_meta(), + "s2.tap_count": self.next_meta(), + "s2.dec_factor": self.next_meta(), + "frame_size": self.next_meta(), + "use_isr" : self.next_meta() + } + + def send_command(self, cmd_id): + cmd_id = np.int32(cmd_id) + # First, send 0 bytes to signal that a command follows + self.send_bytes(b"") + # Then, send the command ID + self.send_word(cmd_id) + + def process_signal(self, signal: PdmSignal): + + # First, send the entire signal to the device. Any output it sends over the + # data probe will get queued up by our parent class, so that it doesn't back + # up the device. We can just read out all the output afterwards. + + # Note that this time we should be sending the signal in the format expected + # by the PDM rx service, NOT in the form expected by the decimator. That + # really just means the channels need to be interleaved. + sig_bytes = signal.to_bytes_interleaved() + self.send_bytes(sig_bytes) + + sample_count = signal.len // ( 32 * self.param["s2.dec_factor"] ) + device_output = np.zeros((self.param["channels"], sample_count), dtype=np.int32) + + # Device sends output as if it had shape (sample_count, channel_count) + for k in range(sample_count): + # Listen for response (should be ctx.channels words) + device_output[:,k] = self.next_data(count=self.param["channels"]) + + return device_output + + + \ No newline at end of file diff --git a/tests/signal/BasicMicArray/src/app.cpp b/tests/signal/BasicMicArray/src/app.cpp new file mode 100644 index 00000000..6f275809 --- /dev/null +++ b/tests/signal/BasicMicArray/src/app.cpp @@ -0,0 +1,121 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include + +#include +#include + +extern "C" { +#include "xscope.h" +} + +#include "mic_array.h" + +#include "app.h" + +#ifndef CHAN_COUNT +# error CHAN_COUNT must be defined. +#endif +#ifndef SAMPLES_PER_FRAME +# error SAMPLES_PER_FRAME must be defined. +#endif +#ifndef USE_ISR +# error USE_ISR must be defined. +#endif + + +// We'll be using a fairly standard mic array setup here, with one big +// exception. Instead of feeding the PDM rx service with a port, we're going +// to feed it from a streaming channel. Under the surface it is just using an +// IN instruction on a resource. As long as it's given a 32-bit word, it +// doesn't particularly care what the resource is. +// Since we're not using a port, we also don't need to worry about setting up +// clocks or any of that silliness +using TMicArray = mic_array::prefab::BasicMicArray; + +TMicArray mics; + + +void app_dec_task( + chanend_t c_frames_out) //non-streaming +{ + mics.Init(); + mics.SetOutputChannel(c_frames_out); + mics.ThreadEntry(); +} + +void app_pdm_rx_isr_setup( + chanend_t c_from_host) +{ + mics.SetPort((port_t)c_from_host); + + mics.InstallPdmRxISR(); + mics.UnmaskPdmRxISR(); +} + + +void app_pdm_task(chanend_t sc_mics) +{ + // We're just going to pretend that the streaming chanend is a port. + mics.SetPort((port_t)sc_mics); + + // no need to start any clocks + mics.PdmRxThreadEntry(); +} + + +void app_output_task(chanend_t c_frames_in) +{ + // Before listening for any frames, use the META_OUT xscope probe to report + // our configuration to the host. This will help make sure the right version + // of this application is being used. + xscope_int(META_OUT, CHAN_COUNT); + xscope_int(META_OUT, 256); // S1_TAP_COUNT + xscope_int(META_OUT, 32); // S1_DEC_FACTOR + xscope_int(META_OUT, STAGE2_TAP_COUNT); + xscope_int(META_OUT, STAGE2_DEC_FACTOR); + xscope_int(META_OUT, SAMPLES_PER_FRAME); + xscope_int(META_OUT, USE_ISR); // Using interrupt + + + // receive the output of the mic array and send it to the host + int32_t frame[CHAN_COUNT][SAMPLES_PER_FRAME]; + while(1){ + ma_frame_rx(&frame[0][0], c_frames_in, CHAN_COUNT, SAMPLES_PER_FRAME); + + // Send it to host sample by sample rather than channel by channel + for(int smp = 0; smp < SAMPLES_PER_FRAME; smp++) { + for(int ch = 0; ch < CHAN_COUNT; ch++){ + xscope_int(DATA_OUT, frame[ch][smp]); + } + } + } +} + + +void app_print_filters() +{ + printf("stage1_coef = [\n"); + for(int a = 0; a < 32; a++){ + printf("0x%08X, 0x%08X, 0x%08X, 0x%08X, \n", + (unsigned) stage1_coef[a*4+0], (unsigned) stage1_coef[a*4+1], + (unsigned) stage1_coef[a*4+2], (unsigned) stage1_coef[a*4+3]); + } + printf("]\n"); + + printf("stage2_coef = [\n"); + for(int a = 0; a < 13; a++){ + printf("0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, \n", + (unsigned) stage2_coef[5*a+0], (unsigned) stage2_coef[5*a+1], + (unsigned) stage2_coef[5*a+2], (unsigned) stage2_coef[5*a+3], + (unsigned) stage2_coef[5*a+4]); + } + printf("]\n"); + + printf("stage2_shr = %d\n", stage2_shr); +} \ No newline at end of file diff --git a/tests/signal/BasicMicArray/src/app.h b/tests/signal/BasicMicArray/src/app.h new file mode 100644 index 00000000..80b25f71 --- /dev/null +++ b/tests/signal/BasicMicArray/src/app.h @@ -0,0 +1,30 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#pragma once + +#include "mic_array.h" + +C_API_START + +// Thread that runs the decimator +MA_C_API +void app_dec_task(chanend_t c_frames_out); + +// Install and unmask ISR +MA_C_API +void app_pdm_rx_isr_setup(chanend_t c_from_host); + +// Thread that receives PDM data +MA_C_API +void app_pdm_task(chanend_t sc_mics); + +// Thread that sends results back to host +MA_C_API +void app_output_task(chanend_t c_frames_in); + +// Print filters (for debug purposes) +MA_C_API +void app_print_filters(); + +C_API_END \ No newline at end of file diff --git a/tests/signal/BasicMicArray/src/main.xc b/tests/signal/BasicMicArray/src/main.xc new file mode 100644 index 00000000..a71b3f5d --- /dev/null +++ b/tests/signal/BasicMicArray/src/main.xc @@ -0,0 +1,171 @@ +// Copyright 2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include + +#include +#include + +#include "app.h" + +#ifndef USE_ISR +# error USE_ISR must be defined. +#endif + +unsafe { + + +// We cannot be guaranteed to read less than this, and we cannot read more than +// this +#define BUFF_SIZE 256 + +void host_words_to_app( + chanend c_from_host, + streaming chanend c_to_app) +{ + xscope_connect_data_from_host(c_from_host); + + // +3 is for any partial word at the end of the read. It will get moved to the + // front and we'll read again, which could be another BUFF_SIZE bytes + char buff[100*BUFF_SIZE+3]; + int buff_lvl = 0; + + /* + The host app can attempt to send [0, 255] bytes on a write attempt. The + xscope logic always adds a null byte at the end, so we expect to receive + [1,256] bytes here. We ignore the null byte at the end, and just consider + the other bytes (i.e. we pretend we received one fewer byte). Then here's + the basic protocol: + + - Loop forever: + - Receive N bytes of data. (after subtracting 1) + - if N > 0: send all whole words to app and loop back. + - if N == 0: + - Enter inner (command) loop: + - Listen for 1 word (4 bytes) from host: + - assert() 4 bytes were received + - Interpret command based on received word value: + - CMD 0: break from command loop back to data loop + - CMD 1: terminate application + + The reason for the command loop is so that the application can terminate + gracefully. This design should also make it relatively easy to add + additional commands if need be. + */ + while(1){ + int dd; + select { + case xscope_data_from_host(c_from_host, &buff[0], dd): + { + dd--; // last byte is always 0 (for some reason) + buff_lvl += dd; + + if(dd == 0){ + // Enter command loop + + // use a separate buffer in case there is a fractional word in the + // data buffer. + char cmd_buff[BUFF_SIZE]; + int cmd_loop = 1; + while(cmd_loop){ + int pp; + select { + case xscope_data_from_host(c_from_host, &cmd_buff[0], pp): + { + assert( (pp-1) == 4 ); + uint32_t cmd = ((uint32_t*)(void*) &cmd_buff[0])[0]; + if(cmd == 0){ + // Break back to data loop + printf("[CMD] Resume data loop.\n"); + cmd_loop = 0; + } else if (cmd == 1){ + // Terminate application + printf("[CMD] Terminate application.\n"); + exit(0); + } else if (cmd == 2){ + // Print filters + printf("[CMD] Print Filters.\n"); + app_print_filters(); + cmd_loop = 0; + } else { + // Unknown command. + printf("[CMD] Unknown command.\n"); + assert(0); + } + break; + } + } + } + + } else { + + // Send all (complete) words to app + int* next_word = ((int*) (void*) &buff[0]); + while(buff_lvl >= sizeof(int)){ + c_to_app <: next_word[0]; + next_word++; + buff_lvl -= sizeof(int); + // We have to be careful about how quickly we push data to the PDM + // rx service. Sending too quickly can mess stuff up or (if PDM rx + // is running in ISR mode) cause a deadlock. This is unfortunate, + // but is only because we're pretending a channel is a port. + // Ultimately, we just need to avoid sending PDM data faster than + // the decimator thread can process the data. Unfortunately, because + // frames are being used, we don't actually know when it's done + // processing a given block of data. So, we'll just insert a + // reasonable delay here. + + // With a 3.072 MHz PDM clock and 1 microphone, we expect to have + // port reads at a rate of 3.072 MHz / 32 = 96 kHz. That rate is + // linear in the number of channels, but we're also always safe if + // we go slower than we need to here. (96 kHz)^(-1) = 10.41 us + delay_microseconds(15); + } + + // if there's 1-3 bytes left move it to the front. + if(buff_lvl) memmove(&buff[0], &next_word[0], buff_lvl); + } + break; + } + } + + // repeat forever + } +} + + +int main() +{ + chan c_from_host; + streaming chan c_to_app; + chan c_frames; + + par { + xscope_host_data(c_from_host); + + on tile[0]: { + host_words_to_app(c_from_host, c_to_app); + } + + on tile[0]: { + xscope_mode_lossless(); + +#if (USE_ISR) + app_pdm_rx_isr_setup((chanend_t) c_to_app); +#endif + + par { +#if !(USE_ISR) + app_pdm_task((chanend_t) c_to_app); +#endif + app_dec_task((chanend_t) c_frames); + app_output_task((chanend_t) c_frames); + } + } + } + return 0; +} + +} \ No newline at end of file diff --git a/tests/signal/BasicMicArray/test_mic_array.py b/tests/signal/BasicMicArray/test_mic_array.py new file mode 100644 index 00000000..d7ddbd7c --- /dev/null +++ b/tests/signal/BasicMicArray/test_mic_array.py @@ -0,0 +1,156 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +###### +# Test: BasicMicArray test +# +# This test is intended to ensure the BasicMicArray prefab appears to produce +# the expected results. +# +# This test does one thing in particular that may seem a bit suspect. Instead of +# reading PDM data from a port, the BasicMicArray is 'tricked' into using a +# streaming chanend as the resource that it reads the data from. Note that doing +# this does not require the BasicMicArray code to be modified in any way (which +# is good). +# +# It also makes the test much easier by evaporating the real-time constraint. +# But that does mean that this test case is in no way verifying that the +# BasicMicArray actually meets the real-time constraint. +# +# Notes: +# - This test assumes that the CMake targets for this app are all already +# built. +# - This test directly launches xgdb, and so the XTC tools must be on your +# path. +# - An appropriate xCore device must be connected to the host using xTag +# - This test should be executed with pytest. To run it, navigate to the root +# of your CMake build directory, and run: +# > pytest path/to/this/dir/test_mic_array.py +###### + +import sys, os, pickle +import numpy as np +from mic_array import filters +from mic_array.pdm_signal import PdmSignal +from micarray_device import MicArrayDevice +from mic_array.case_replay import InitReplay +import pytest +from conftest import test_params, xe_file_path, FLAGS, DevCommand + + +class Test_BasicMicArray(object): + + DEFAULT_FILTERS_FILE = os.path.join(os.path.dirname(__file__), "default_filters.pkl") + + @pytest.fixture(autouse=True) + def __init_case(self, request): + np.set_printoptions(threshold=sys.maxsize, + linewidth=80) + + @pytest.fixture(autouse=True) + def __init_flags(self, request): + for f in FLAGS: + fs = f.replace("-","_") + op = request.config.getoption(fs) + self.__dict__[fs] = op + + def default_filter(self): + # load the default filters from the pkl file. + with open(self.DEFAULT_FILTERS_FILE, "rb") as filt_file: + stage1, stage2 = pickle.load(filt_file) + + s1_coef, s1_df = stage1 + s2_coef, s2_df = stage2 + + assert s1_df == 32 + assert s2_df == 6 + assert len(s1_coef) == 257 + assert len(s2_coef) == 65 + + # first stage gets truncated to 256 taps + s1_coef = s1_coef[:256] + + s1_filter = filters.Stage1Filter(s1_coef, s1_df) + s2_filter = filters.Stage2Filter(s2_coef, s2_df) + + if self.debug_print_filters: + # print stage1 as uint32 so that it is easy to compare to the device + s1_coef_bytes = s1_filter.ToXCoreCoefArray().tobytes() + s1_coef_words = np.frombuffer(s1_coef_bytes, dtype=np.uint32) + print(f"Stage1 Filter: {repr(np.array([hex(x) for x in s1_coef_words]))}") + + print(f"Stage2 Filter: {np.array([('0x%08X' % np.uint32(x)) for x in s2_filter.CoefInt32])}") + print(f"Stage2 Filter shr: {s2_filter.ShrInt32}") + + return filters.TwoStageFilter(s1_filter, s2_filter) + + + @pytest.mark.parametrize('xe_param', test_params) + def test_BasicMicArray(self, request, xe_param, replay_mode): + + chans, frame_size, use_isr = xe_param + + print(f"\nParams[Channels: {chans}; Frame Size: {frame_size}; Use ISR: {use_isr}]") + + xe_path = xe_file_path(xe_param, request.config.getoption("build_dir")) + + assert os.path.isfile(xe_path), f"Required executable does not exist ({xe_path})" + + ## Some of the work can be done before talking to the device. (this also + ## minimizes the likelihood of test exceptions putting the device into a + ## state where it needs to be power-cycled.) + with InitReplay(request.node.name, replay_mode) as replay: + + # Note: --frames option is ignored if the --load-case option is used + frames = request.config.getoption("frames") + frames = replay.apply("frames", frames) + + # Generate random filter + filter = self.default_filter() + + # Number of PDM samples (per channel) required to make the mic array + # output a single frame + samp_per_frame = 32 * filter.s2.DecimationFactor * frame_size + + # Total PDM samples (per channel) + samp_total = samp_per_frame * frames + + # Generate random PDM signal + sig = PdmSignal.random(chans, samp_total) + sig.signal = replay.apply("pdm_signal", sig.signal) + + # Compute the expected output + # Note: This assumes DCOE is disabled (which it should be in this app) + expected = filter.Filter(sig.signal) + + if self.print_output: print(f"Expected output: {expected}") + + ## Now see what the device says. + with MicArrayDevice(xe_path, quiet_xgdb=not self.print_xgdb) as dev: + + # Make sure we're talking to the correct application + assert dev.param["channels"] == chans + assert dev.param["s1.dec_factor"] == 32 + assert dev.param["s1.tap_count"] == 256 + assert dev.param["s2.dec_factor"] == 6 + assert dev.param["s2.tap_count"] == 65 + assert dev.param["frame_size"] == frame_size + assert dev.param["use_isr"] == use_isr + + # If we're supposed to print filters, tell the device to do so + if self.debug_print_filters: dev.send_command(DevCommand.PRINT_FILTERS.value) + + # Get the device's output + device_output = dev.process_signal(sig) + + if self.print_output: print(f"Device output: {device_output}") + + dev.send_command(DevCommand.TERMINATE.value) + + # The second stage filter will usually yield exactly correct results, but + # not always, because the 64-bit partial products of the inner product + # (i.e. filter_state[:] * filter_coef[:]) have a rounding-right-shift + # applied to them prior to being summed. + result_diff = np.max(np.abs(expected - device_output)) + assert result_diff <= 1 + diff --git a/tests/signal/CMakeLists.txt b/tests/signal/CMakeLists.txt new file mode 100644 index 00000000..6ddc53d2 --- /dev/null +++ b/tests/signal/CMakeLists.txt @@ -0,0 +1,9 @@ + +add_custom_target( tests-signal ) + + +add_subdirectory( TwoStageDecimator ) +add_subdirectory( BasicMicArray ) + +add_dependencies(tests tests-signal) + diff --git a/tests/signal/README.rst b/tests/signal/README.rst new file mode 100644 index 00000000..989f8a31 --- /dev/null +++ b/tests/signal/README.rst @@ -0,0 +1,49 @@ + +tests-signal +============ + +Tests in this directory are meant to ensure that the mic array signal processing +works as expected. + +Each of these tests are run using ``pytest``, which will launch the application +in the debugger. + +* `BasicMicArray`_ - Build tests using the vanilla API +* `TwoStageDecimator`_ - Build tests using the prefab API + +Requirements +------------ + +To run these tests, you will need Python3 with ``pytest`` and ``numpy``. + +> TODO: Create requirements.txt for python virtual environment + + +Build Targets +------------- + +To build all ``tests-signal`` targets, (with your CMake project properly +configured) navigate to your CMake build directory and use the following +command: + +:: + + make tests-signal + + +Running Test Apps +----------------- + +Test cases should be run from the base of your CMake build directory. From +there, with Python3 and the XMOS XTC tools in your path, simply call pytest with +the path to the test script as the only necessary argument. For example, to run +the TwoStageDecimator stage2 tests: + +:: + + pytest ..\tests\signal\TwoStageDecimator\test_stage2.py + + + +.. _BasicMicArray: BasicMicArray/ +.. _TwoStageDecimator: TwoStageDecimator/ \ No newline at end of file diff --git a/tests/signal/TwoStageDecimator/CMakeLists.txt b/tests/signal/TwoStageDecimator/CMakeLists.txt new file mode 100644 index 00000000..b4215b1d --- /dev/null +++ b/tests/signal/TwoStageDecimator/CMakeLists.txt @@ -0,0 +1,81 @@ + +set( APP_NAME tests-signal-decimator ) + +set( TARGET_XN XVF3610_Q60A.xn ) + +add_custom_target( ${APP_NAME} ) +add_dependencies( tests-signal ${APP_NAME} ) + +get_filename_component(XSCOPE_CONFIG config.xscope ABSOLUTE) + +set(APP_COMPILE_FLAGS + "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_XN}" + "${XSCOPE_CONFIG}" + "-fxscope" + "-mcmodel=large" + "-Wno-xcore-fptrgroup" + "-Wno-unknown-pragmas" + "-Wno-format" + "-g" + "-O2" +) + +set(APP_LINK_FLAGS ${APP_COMPILE_FLAGS} ) +list( APPEND APP_LINK_FLAGS "-report" ) + + +set( APP_INCLUDES "src" ) + +file( GLOB_RECURSE APP_SOURCES + "src/*.c" + "src/*.xc" + "src/*.cpp" ) + + + +macro( create_target MICS S2DEC S2TAPS ) + + set( TARG_NAME "${APP_NAME}_${MICS}_${S2DEC}_${S2TAPS}" ) + + add_executable( ${TARG_NAME} ) + + target_compile_options( ${TARG_NAME} + PRIVATE ${APP_COMPILE_FLAGS} ) + + target_link_options( ${TARG_NAME} + PRIVATE ${APP_LINK_FLAGS} ) + + target_sources( ${TARG_NAME} + PRIVATE ${APP_SOURCES} ) + + target_include_directories( ${TARG_NAME} + PRIVATE ${APP_INCLUDES} ) + + target_link_libraries( ${TARG_NAME} + lib_xcore_math + lib_mic_array ) + + target_compile_definitions( ${TARG_NAME} + PRIVATE "CHAN_COUNT=${MICS}" + "S2_DEC_FACT=${S2DEC}" + "S2_TAPS=${S2TAPS}" + ) + + add_dependencies( ${APP_NAME} ${TARG_NAME} ) +endmacro() + +# NOTE: It doesn't really make senes for the S2TapCount to be smaller +# than the S2DecFactor -- also that breaks the test. + +# Application parameters +# Mics S2DecFactor S2TapCount +create_target( 1 1 1 ) +create_target( 1 1 2 ) +create_target( 2 1 1 ) +create_target( 2 1 16 ) +create_target( 4 6 16 ) +create_target( 8 6 48 ) +create_target( 1 6 48 ) +create_target( 2 6 65 ) +create_target( 4 3 65 ) +create_target( 8 3 24 ) diff --git a/tests/signal/TwoStageDecimator/README.rst b/tests/signal/TwoStageDecimator/README.rst new file mode 100644 index 00000000..f8c3c796 --- /dev/null +++ b/tests/signal/TwoStageDecimator/README.rst @@ -0,0 +1,41 @@ + +tests-signal-TwoStageDecimator +============================== + +Tests in this directory ensure that the signal processing performed by the +``TwoStageDecimator`` class template behaves as expected. + +Each of these scripts are run using ``pytest``, which will launch the +application in the debugger. + +* ``test_stage1.py`` - Tests the first stage decimator in various configurations +* ``test_stage2.py`` - Tests the second stage decimator in various configurations + + +Build Targets +------------- + +Several CMake targets are generated, and all should be built prior to running +the test script in Pytest. + +To build all ``tests-signal-TwoStageDecimator`` targets, (with your CMake +project properly configured) navigate to your CMake build directory and use the +following command: + +:: + + make tests-signal-TwoStageDecimator + + +Running Tests +------------- + +Test cases should be run from the base of your CMake build directory. From +there, with Python3 and the XMOS XTC tools in your path, simply call pytest with +the path to the test script as the only necessary argument. For example, to run +the TwoStageDecimator stage2 tests: + +:: + + pytest ..\tests\signal\TwoStageDecimator\test_stage2.py + diff --git a/tests/signal/TwoStageDecimator/XVF3610_Q60A.xn b/tests/signal/TwoStageDecimator/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/tests/signal/TwoStageDecimator/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/AN00217_app_high_resolution_delay_example/config.xscope b/tests/signal/TwoStageDecimator/config.xscope similarity index 86% rename from examples/AN00217_app_high_resolution_delay_example/config.xscope rename to tests/signal/TwoStageDecimator/config.xscope index 15402889..76ac74fe 100644 --- a/examples/AN00217_app_high_resolution_delay_example/config.xscope +++ b/tests/signal/TwoStageDecimator/config.xscope @@ -19,5 +19,7 @@ - + + + diff --git a/tests/signal/TwoStageDecimator/conftest.py b/tests/signal/TwoStageDecimator/conftest.py new file mode 100644 index 00000000..dbafbf5d --- /dev/null +++ b/tests/signal/TwoStageDecimator/conftest.py @@ -0,0 +1,60 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +import sys, os, pytest +sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..','..',"script")) +from mic_array.case_replay import ReplayMode + +def pytest_addoption(parser): + parser.addoption("--build-dir", action="store", default='.') + parser.addoption("--blocks", type=int, default=160) + parser.addoption("--dump-obj", action="store_true") + parser.addoption("--save-case", action="store_true") + parser.addoption("--load-case", action="store_true") + parser.addoption("--print-output", action="store_true") + +# Relative to build directory +APP_BUILD_DIR = os.path.join('tests','signal','TwoStageDecimator') + +# Each app is prefixed with this +XE_NAME_ROOT = 'tests-signal-decimator' + +# Parameters come from CMakeLists.txt. If that changes, this may also need +# to change. +xe_params = [ + (1, 1, 1), + (1, 1, 2), + (2, 1, 1), + (2, 1, 16), + (4, 6, 16), + (8, 6, 48), + (1, 6, 48), + (2, 6, 65), + (4, 3, 65), + (8, 3, 24), +] + +test_params = [ + pytest.param((x,y,z), id=f"{x}ch_{y}df_{z}tc") for x,y,z in xe_params +] + +# Get the file path given params and build_dir +def xe_file_path(params, build_dir): + xe_name = f"{XE_NAME_ROOT}_{params[0]}_{params[1]}_{params[2]}.xe" + xe_path = os.path.abspath( + os.path.join(build_dir, APP_BUILD_DIR, xe_name) + ) + return xe_path + +@pytest.fixture() +def replay_mode(request): + save = request.config.getoption("save_case") + load = request.config.getoption("load_case") + if save and load: + raise Exception("Cannot use both --save-case and --load-case options.") + mode = (ReplayMode.SAVE_VECTORS if save else + (ReplayMode.LOAD_VECTORS if load else + ReplayMode.DO_NOTHING) ) + if mode != ReplayMode.DO_NOTHING: + print(f"Using replay mode: {mode.name}") + return mode \ No newline at end of file diff --git a/tests/signal/TwoStageDecimator/decimator_device.py b/tests/signal/TwoStageDecimator/decimator_device.py new file mode 100644 index 00000000..2e0d5ed5 --- /dev/null +++ b/tests/signal/TwoStageDecimator/decimator_device.py @@ -0,0 +1,69 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + + +import numpy as np +from mic_array.device_context import DeviceContext +from mic_array import filters +from mic_array.pdm_signal import PdmSignal + + +class DecimatorDevice(DeviceContext): + + def __init__(self, xe_path, /, **kwargs): + super().__init__(xe_path, probes=["meta_out", "data_out"], **kwargs) + + self.channels = None # unknown initially + + def next_data(self, count=1): + return self.probe_next("data_out", count=count) + + def next_meta(self, count=1): + return self.probe_next("meta_out", count=count) + + def _on_connect(self): + self.param = { + "channels": self.next_meta(), + "s1.tap_count": self.next_meta(), + "s1.dec_factor": self.next_meta(), + "s2.tap_count": self.next_meta(), + "s2.dec_factor": self.next_meta(), + } + self.channels = self.param["channels"] + + def send_stage1_filter(self, s1_filter: filters.Stage1Filter): + xcore_coef = s1_filter.ToXCoreCoefArray().tobytes() + self.send_bytes(xcore_coef) + + def send_stage2_filter(self, s2_filter: filters.Stage2Filter): + xcore_coef = s2_filter.CoefInt32.tobytes() + self.send_bytes(xcore_coef) + self.send_word(s2_filter.ShrInt32) + + def send_decimator(self, filter: filters.TwoStageFilter): + self.send_stage1_filter(filter.s1) + self.send_stage2_filter(filter.s2) + + def process_signal(self, filter: filters.TwoStageFilter, + signal: PdmSignal): + + blocks = signal.block_count(filter.DecimationFactor) + + self.send_decimator(filter) + self.send_word(blocks) + + sig_bytes = signal.to_bytes(filter.s2.DecimationFactor) + device_output = np.zeros((self.channels, blocks), dtype=np.int32) + + # Bytes per block + L = self.channels * filter.s2.DecimationFactor * 4 + for k in range(blocks): + # Send one block at a time + self.send_bytes(sig_bytes[k*L:(k+1)*L]) + # Listen for response (should be ctx.channels words) + device_output[:,k] = self.next_data(count=self.channels) + + return device_output + + + \ No newline at end of file diff --git a/tests/signal/TwoStageDecimator/src/main.xc b/tests/signal/TwoStageDecimator/src/main.xc new file mode 100644 index 00000000..26f620a7 --- /dev/null +++ b/tests/signal/TwoStageDecimator/src/main.xc @@ -0,0 +1,81 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include + +#include +#include + +void run(streaming chanend); + +unsafe { + + +// We can't be guaranteed to read less than this, and we cannot read more than +// this +#define BUFF_SIZE 256 + +void host_words_to_app( + chanend c_from_host, + streaming chanend c_to_app) +{ + xscope_connect_data_from_host(c_from_host); + + // +3 is for any partial word at the end of the read + char buff[BUFF_SIZE+3]; + int buff_lvl = 0; + + while(1){ + int dd; + select { + case xscope_data_from_host(c_from_host, &buff[0], dd): + { + dd--; // last byte is always 0 (for some reason) + buff_lvl += dd; + // printf("& Received %d bytes.\n", dd); + + // Send all (complete) words to app + int* next_word = ((int*) (void*) &buff[0]); + while(buff_lvl >= sizeof(int)){ + c_to_app <: next_word[0]; + next_word++; + buff_lvl -= sizeof(int); + } + + // if there's 1-3 bytes left move it to the front. + if(buff_lvl) memmove(&buff[0], &next_word[0], buff_lvl); + + break; + } + } + + // repeat forever + } +} + + +int main() +{ + chan c_from_host; + streaming chan c_to_app; + + par { + xscope_host_data(c_from_host); + + on tile[0]: { + host_words_to_app(c_from_host, c_to_app); + } + + on tile[0]: { + xscope_mode_lossless(); + run(c_to_app); + printf("Done.\n"); + exit(0); + } + } + return 0; +} + +} \ No newline at end of file diff --git a/tests/signal/TwoStageDecimator/src/run.cpp b/tests/signal/TwoStageDecimator/src/run.cpp new file mode 100644 index 00000000..ecc7c8f7 --- /dev/null +++ b/tests/signal/TwoStageDecimator/src/run.cpp @@ -0,0 +1,98 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include + +#include +#include + +extern "C" { +#include "xscope.h" +} + +#include "mic_array.h" + +#ifndef CHAN_COUNT +# error CHAN_COUNT must be defined. +#endif +#ifndef S2_TAPS +# error S2_TAPS must be defined. +#endif +#ifndef S2_DEC_FACT +# error S2_DEC_FACT must be defined. +#endif + +// Will be loaded from file +static uint32_t test_stage1_coef[128]; + +static int32_t test_stage2_coef[S2_TAPS]; +static right_shift_t test_stage2_shr; + + +void load_stage1(chanend_t c_from_host) +{ + printf("Listening for 1st stage filter coefficients..\n"); + s_chan_in_buf_word(c_from_host, + &test_stage1_coef[0], + sizeof(test_stage1_coef)/sizeof(uint32_t)); + printf("Stage 1 coefficients received.\n"); +} + +void load_stage2(chanend_t c_from_host) +{ + printf("Listening for 2nd stage filter coefficients..\n"); + s_chan_in_buf_word(c_from_host, + reinterpret_cast(&test_stage2_coef[0]), + sizeof(test_stage2_coef)/sizeof(int32_t)); + test_stage2_shr = s_chan_in_word(c_from_host); + printf("Stage 2 coefficients received.\n"); +} + + +void process_signal(chanend_t c_from_host) +{ + constexpr unsigned BLOCK_WORDS = CHAN_COUNT * S2_DEC_FACT; + + using TDecimator = mic_array::TwoStageDecimator; + + TDecimator dec; + dec.Init(const_cast(test_stage1_coef), + test_stage2_coef, test_stage2_shr); + + // Host will tell us how many blocks it intends to send + unsigned block_count = s_chan_in_word(c_from_host); + + uint32_t buffer[BLOCK_WORDS]; + int32_t sample_out[CHAN_COUNT]; + + printf("Processing %u blocks of PDM samples..\n", block_count); + for(int k = 0; k < block_count; k++){ + s_chan_in_buf_word(c_from_host, &buffer[0], BLOCK_WORDS); + dec.ProcessBlock(sample_out, buffer); + for(int c = 0; c < CHAN_COUNT; c++){ + xscope_int(DATA_OUT, sample_out[c]); + } + } + printf("Finished processing PDM signal.\n"); +} + +extern "C" +void run(chanend_t c_from_host) +{ + // Tell the host script what parameters are currently being used + xscope_int(META_OUT, CHAN_COUNT); + xscope_int(META_OUT, 256); // S1_TAP_COUNT + xscope_int(META_OUT, 32); // S1_DEC_FACTOR + xscope_int(META_OUT, S2_TAPS); + xscope_int(META_OUT, S2_DEC_FACT); + + load_stage1(c_from_host); + load_stage2(c_from_host); + + process_signal(c_from_host); +} \ No newline at end of file diff --git a/tests/signal/TwoStageDecimator/test_stage1.py b/tests/signal/TwoStageDecimator/test_stage1.py new file mode 100644 index 00000000..ef750541 --- /dev/null +++ b/tests/signal/TwoStageDecimator/test_stage1.py @@ -0,0 +1,112 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +###### +# Test: TwoStageDecimator stage 1 test +# +# This test is intended to make sure the first stage of the TwoStageDecimator is +# producing correct results. +# +# Notes: +# - This test assumes that the CMake targets for this app are all already +# built. +# - This test directly launches xgdb, and so the XTC tools must be on your +# path. +# - An appropriate xCore device must be connected to the host using xTag +# - This test should be executed with pytest. To run it, navigate to the root +# of your CMake build directory, and run: +# > pytest path/to/this/dir/test_stage2.py +###### + +import sys, os, time +import numpy as np +from mic_array import filters +from mic_array.pdm_signal import PdmSignal +from decimator_device import DecimatorDevice +from mic_array.case_replay import InitReplay +import pytest +from conftest import test_params, xe_file_path + + +class Test_Stage2(object): + + @pytest.fixture(autouse=True) + def __init_case(self, request): + np.set_printoptions(threshold=sys.maxsize, + linewidth=80) + self.print_out = request.config.getoption("print_output") + + def gen_filter(self, s2_tap_count, s2_dec_factor, replay): + # This test uses a random first stage filter. No arithmetic saturation is + # possible, regardless of what we pick. + s1_coef = np.random.random_sample(256) - 1.0 + s1_coef = replay.apply("s1_coef", s1_coef) + s1_filter = filters.Stage1Filter(s1_coef) + + # This test uses a simple pass-through filter for the second stage decimator. + # (i.e. b = [1.0, 0, 0, 0, 0, ...]) + # The output from the full decimator should then be exactly what was output by + # the first stage, with (s2_dec_factor-1) of every (s2_dec_factor) samples + # dropped. + s2_coef = np.zeros((s2_tap_count), dtype=np.float) + s2_coef[0] = 1.0 + s2_coef = s2_coef / np.sum(np.abs(s2_coef)) + s2_coef = replay.apply("s2_coef", s2_coef) + s2_filter = filters.Stage2Filter(s2_coef, s2_dec_factor) + + return filters.TwoStageFilter(s1_filter, s2_filter) + + + @pytest.mark.parametrize('xe_param', test_params) + def test_stage2(self, request, xe_param, replay_mode): + + chans, s2_df, s2_taps = xe_param + + print(f"\nParams[Channels: {chans}; S2 Dec Factor: {s2_df}; S2 Tap Count: {s2_taps}]") + + xe_path = xe_file_path(xe_param, request.config.getoption("build_dir")) + + assert os.path.isfile(xe_path) + + ## Most of the work can be done before talking to the device. (this also + ## minimizes the likelihood of test exceptions putting the device into a + ## state where it needs to be power-cycled.) + with InitReplay(request.node.name, replay_mode) as replay: + + # Note: --blocks option is ignored if the --load-case option is used + blocks = request.config.getoption("blocks") + blocks = replay.apply("blocks", blocks) + + # Generate random filter + filter = self.gen_filter(s2_taps, s2_df, replay) + + # Generate random PDM signal + sig = PdmSignal.random(chans, 32 * blocks * filter.s2.DecimationFactor) + sig.signal = replay.apply("pdm_signal", sig.signal) + + # Compute the expected output + expected = filter.Filter(sig.signal) + + if self.print_out: print(f"Expected output: {expected}") + + ## Now see what the device says. + with DecimatorDevice(xe_path) as dev: + + assert dev.param["channels"] == chans + assert dev.param["s1.dec_factor"] == 32 + assert dev.param["s1.tap_count"] == 256 + assert dev.param["s2.dec_factor"] == s2_df + assert dev.param["s2.tap_count"] == s2_taps + + # Get the device's output + device_output = dev.process_signal(filter, sig) + + if self.print_out: print(f"Device output: {device_output}") + + # The second stage filter will usually yield exactly correct results, but + # not always, because the 64-bit partial products of the inner product + # (i.e. filter_state[:] * filter_coef[:]) have a rounding-right-shift + # applied to them prior to being summed. + result_diff = np.max(np.abs(expected - device_output)) + assert result_diff <= 1 + diff --git a/tests/signal/TwoStageDecimator/test_stage2.py b/tests/signal/TwoStageDecimator/test_stage2.py new file mode 100644 index 00000000..4620ae1b --- /dev/null +++ b/tests/signal/TwoStageDecimator/test_stage2.py @@ -0,0 +1,115 @@ +# Copyright 2022 XMOS LIMITED. +# This Software is subject to the terms of the XMOS Public Licence: Version 1. + +###### +# Test: TwoStageDecimator stage 2 test +# +# This test is intended to make sure the second stage of the TwoStageDecimator +# is producing correct results. This test relies on the assumption that the +# first stage decimator works correctly (all test vectors go through the first +# stage before they get to the second stage), so technically it's looking at the +# whole TwoStageDecimator input->output. If this test is failing but +# test_stage1.py works, then there is an issue in the second stage (or this test +# is wrong). +# +# Notes: +# - This test assumes that the CMake targets for this app are all already +# built. +# - This test directly launches xgdb, and so the XTC tools must be on your +# path. +# - An appropriate xCore device must be connected to the host using xTag +# - This test should be executed with pytest. To run it, navigate to the root +# of your CMake build directory, and run: +# > pytest path/to/this/dir/test_stage2.py +###### + +import sys, os, time +import numpy as np +from mic_array import filters +from mic_array.pdm_signal import PdmSignal +from decimator_device import DecimatorDevice +from mic_array.case_replay import InitReplay +import pytest +from conftest import test_params, xe_file_path + + +class Test_Stage2(object): + + @pytest.fixture(autouse=True) + def __init_case(self, request): + np.set_printoptions(threshold=sys.maxsize, + linewidth=80) + self.print_out = request.config.getoption("print_output") + + + def gen_filter(self, s2_tap_count, s2_dec_factor, replay): + # This test uses a random first stage filter. No arithmetic saturation is + # possible, regardless of what we pick. + + s1_coef = np.random.random_sample(256) - 1.0 + s1_coef = replay.apply("s1_coef", s1_coef) + s1_filter = filters.Stage1Filter(s1_coef) + + # We'll generate a random filter for the second stage as well. We'll normalize + # it so that we're not worried about saturating. + s2_coef = np.random.random_sample(s2_tap_count) - 1.0 + s2_coef = s2_coef / np.sum(np.abs(s2_coef)) + s2_coef = replay.apply("s2_coef", s2_coef) + s2_filter = filters.Stage2Filter(s2_coef, s2_dec_factor) + + return filters.TwoStageFilter(s1_filter, s2_filter) + + + @pytest.mark.parametrize('xe_param', test_params) + def test_stage2(self, request, xe_param, replay_mode): + + chans, s2_df, s2_taps = xe_param + + print(f"\nParams[Channels: {chans}; S2 Dec Factor: {s2_df}; S2 Tap Count: {s2_taps}]") + + xe_path = xe_file_path(xe_param, request.config.getoption("build_dir")) + + assert os.path.isfile(xe_path) + + ## Most of the work can be done before talking to the device. (this also + ## minimizes the likelihood of test exceptions putting the device into a + ## state where it needs to be power-cycled.) + with InitReplay(request.node.name, replay_mode) as replay: + + # Note: --blocks option is ignored if the --load-case option is used + blocks = request.config.getoption("blocks") + blocks = replay.apply("blocks", blocks) + + # Generate random filter + filter = self.gen_filter(s2_taps, s2_df, replay) + + # Generate random PDM signal + sig = PdmSignal.random(chans, 32 * blocks * filter.s2.DecimationFactor) + sig.signal = replay.apply("pdm_signal", sig.signal) + + # Compute the expected output + expected = filter.Filter(sig.signal) + + if self.print_out: print(f"Expected output: {expected}") + + ## Now see what the device says. + with DecimatorDevice(xe_path) as dev: + + assert dev.param["channels"] == chans + assert dev.param["s1.dec_factor"] == 32 + assert dev.param["s1.tap_count"] == 256 + assert dev.param["s2.dec_factor"] == s2_df + assert dev.param["s2.tap_count"] == s2_taps + + # Get the device's output + device_output = dev.process_signal(filter, sig) + + if self.print_out: print(f"Device output: {device_output}") + + # The second stage filter will usually yield exactly correct results, but + # not always, because the 64-bit partial products of the inner product + # (i.e. filter_state[:] * filter_coef[:]) have a rounding-right-shift + # applied to them prior to being summed. + result_diff = np.max(np.abs(expected - device_output)) + assert result_diff <= 1 + diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt new file mode 100644 index 00000000..09967c2d --- /dev/null +++ b/tests/unit/CMakeLists.txt @@ -0,0 +1,49 @@ + +set( APP_NAME tests-unit ) + +set( TARGET_XN XVF3610_Q60A.xn ) + + +set(APP_COMPILE_FLAGS + "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_XN}" + "-fxscope" + "-mcmodel=large" + "-Wno-xcore-fptrgroup" + "-Wno-unknown-pragmas" + "-Wno-format" + "-g" + "-O2" +) + +set(APP_LINK_FLAGS ${APP_COMPILE_FLAGS} ) +list( APPEND APP_LINK_FLAGS "-report" ) +list( APPEND APP_LINK_FLAGS "-fcmdline-buffer-bytes=1024" ) + + +set( APP_INCLUDES "src" ) + +file( GLOB_RECURSE APP_SOURCES + "src/*.c" + "src/*.xc" + "src/*.cpp" ) + +add_executable( ${APP_NAME} ) + +target_compile_options( ${APP_NAME} +PRIVATE ${APP_COMPILE_FLAGS} ) + +target_link_options( ${APP_NAME} +PRIVATE ${APP_LINK_FLAGS} ) + +target_sources( ${APP_NAME} +PRIVATE ${APP_SOURCES} ) + +target_include_directories( ${APP_NAME} +PRIVATE ${APP_INCLUDES} ) + +target_link_libraries( ${APP_NAME} + lib_xcore_math + lib_mic_array + unity ) + +add_dependencies( tests ${APP_NAME} ) \ No newline at end of file diff --git a/tests/unit/README.rst b/tests/unit/README.rst new file mode 100644 index 00000000..bf7f3cf1 --- /dev/null +++ b/tests/unit/README.rst @@ -0,0 +1,30 @@ + +tests-unit +========== + +This directory contains unit tests for various elements of this library. + +These tests use the Unity unit testing framework, which should have been +automatically fetched when configuring the CMake project. + + +Build Target +------------ + +To build the unit tests, navigate to your CMake build directory and use the +following command: + +:: + + make tests-unit + + +Running Tests +------------- + +Test cases are executed by running the generated binary with ``xrun``. E.g., from the CMake build directory: + +:: + + xrun --xscope tests\unit\tests-unit.xe + diff --git a/tests/unit/XVF3610_Q60A.xn b/tests/unit/XVF3610_Q60A.xn new file mode 100644 index 00000000..7271d72b --- /dev/null +++ b/tests/unit/XVF3610_Q60A.xn @@ -0,0 +1,92 @@ + + + + tileref tile[2] + tileref usb_tile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/unit/src/main.c b/tests/unit/src/main.c new file mode 100644 index 00000000..88ec78a0 --- /dev/null +++ b/tests/unit/src/main.c @@ -0,0 +1,32 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include + +#include "unity_fixture.h" + +int main(int argc, const char* argv[]) +{ + xscope_config_io(XSCOPE_IO_BASIC); + + UnityGetCommandLineOptions(argc, argv); + UnityBegin(argv[0]); + + RUN_TEST_GROUP(dcoe_state_init); + RUN_TEST_GROUP(dcoe_filter); + RUN_TEST_GROUP(DcoeSampleFilter); + + RUN_TEST_GROUP(ma_frame_tx_rx); + RUN_TEST_GROUP(ma_frame_tx_rx_transpose); + RUN_TEST_GROUP(ChannelFrameTransmitter); + RUN_TEST_GROUP(FrameOutputHandler); + + RUN_TEST_GROUP(deinterleave2); + RUN_TEST_GROUP(deinterleave4); + RUN_TEST_GROUP(deinterleave8); + + RUN_TEST_GROUP(deinterleave_pdm_samples); + + return UNITY_END(); +} diff --git a/tests/unit/src/test_ChannelFrameTransmitter.cpp b/tests/unit/src/test_ChannelFrameTransmitter.cpp new file mode 100644 index 00000000..37cfdf68 --- /dev/null +++ b/tests/unit/src/test_ChannelFrameTransmitter.cpp @@ -0,0 +1,170 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/cpp/OutputHandler.hpp" + +extern "C" { + + channel_t c_frames; + + TEST_GROUP_RUNNER(ChannelFrameTransmitter) { + RUN_TEST_CASE(ChannelFrameTransmitter, NoArgConstructor); + RUN_TEST_CASE(ChannelFrameTransmitter, OneArgConstructor); + RUN_TEST_CASE(ChannelFrameTransmitter, SetChannel); + + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_1x1 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_1x16 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_1x256 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_1x1024); + + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_2x1 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_2x16 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_2x256 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_2x1024); + + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_4x1 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_4x16 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_4x256 ); + RUN_TEST_CASE(ChannelFrameTransmitter, OutputFrame_4x1024); + } + + TEST_GROUP(ChannelFrameTransmitter); + + TEST_SETUP(ChannelFrameTransmitter) { + c_frames = chan_alloc(); + } + + TEST_TEAR_DOWN(ChannelFrameTransmitter) { + chan_free(c_frames); + } + + + static unsigned stack[8000]; + static void* stack_start = stack_base(stack, 8000); + +} + +template +static void send_frame(void* vframe) +{ + auto frame = reinterpret_cast(vframe); + + mic_array::ChannelFrameTransmitter frame_tx(c_frames.end_a); + + frame_tx.OutputFrame(frame); + +} + +template +static +void test_ChannelFrameTransmitter() +{ + srand(7685664*CHANS + SAMPLE_COUNT); + + constexpr unsigned LOOP_COUNT=400; + + for(int r = 0; r < LOOP_COUNT; r++){ + int32_t exp_frame[CHANS][SAMPLE_COUNT]; + + for(int c = 0; c < CHANS; c++) + for(int s = 0; s < SAMPLE_COUNT; s++) + exp_frame[c][s] = rand(); + + run_async( send_frame, &exp_frame[0][0], stack_start); + + int32_t received[CHANS][SAMPLE_COUNT]; + + ma_frame_rx(&received[0][0], c_frames.end_b, CHANS, SAMPLE_COUNT); + + TEST_ASSERT_EQUAL_INT32_ARRAY(&exp_frame[0][0], &received[0][0], CHANS * SAMPLE_COUNT); + } +} + +extern "C" { + + TEST(ChannelFrameTransmitter, NoArgConstructor) { + if(1){ + auto frame_tx = mic_array::ChannelFrameTransmitter<1,1>(); + TEST_ASSERT_EQUAL_UINT32(0, frame_tx.GetChannel()); + } + if(1){ + auto frame_tx = mic_array::ChannelFrameTransmitter<8,1>(); + TEST_ASSERT_EQUAL_UINT32(0, frame_tx.GetChannel()); + } + if(1){ + auto frame_tx = mic_array::ChannelFrameTransmitter<2,4>(); + TEST_ASSERT_EQUAL_UINT32(0, frame_tx.GetChannel()); + } + if(1){ + auto frame_tx = mic_array::ChannelFrameTransmitter<4,256>(); + TEST_ASSERT_EQUAL_UINT32(0, frame_tx.GetChannel()); + } + } + + TEST(ChannelFrameTransmitter, OneArgConstructor) { + srand(57645674); + if(1){ + uint32_t c = rand(); + auto frame_tx = mic_array::ChannelFrameTransmitter<1,1>(c); + TEST_ASSERT_EQUAL_UINT32(c, frame_tx.GetChannel()); + } + if(1){ + uint32_t c = rand(); + auto frame_tx = mic_array::ChannelFrameTransmitter<8,1>(c); + TEST_ASSERT_EQUAL_UINT32(c, frame_tx.GetChannel()); + } + if(1){ + uint32_t c = rand(); + auto frame_tx = mic_array::ChannelFrameTransmitter<2,4>(c); + TEST_ASSERT_EQUAL_UINT32(c, frame_tx.GetChannel()); + } + if(1){ + uint32_t c = rand(); + auto frame_tx = mic_array::ChannelFrameTransmitter<4,256>(c); + TEST_ASSERT_EQUAL_UINT32(c, frame_tx.GetChannel()); + } + } + + TEST(ChannelFrameTransmitter, SetChannel) { + + srand(45746236); + + auto frame_tx = mic_array::ChannelFrameTransmitter<4,8>(); + TEST_ASSERT_EQUAL_UINT32(0, frame_tx.GetChannel()); + + for(int k = 0; k < 400; k++){ + uint32_t c = rand(); + frame_tx.SetChannel(c); + TEST_ASSERT_EQUAL_UINT32(c, frame_tx.GetChannel()); + } + } + + TEST(ChannelFrameTransmitter, OutputFrame_1x1) { test_ChannelFrameTransmitter<1,1>(); } + TEST(ChannelFrameTransmitter, OutputFrame_1x16) { test_ChannelFrameTransmitter<1,16>(); } + TEST(ChannelFrameTransmitter, OutputFrame_1x256) { test_ChannelFrameTransmitter<1,256>(); } + TEST(ChannelFrameTransmitter, OutputFrame_1x1024) { test_ChannelFrameTransmitter<1,1024>(); } + + TEST(ChannelFrameTransmitter, OutputFrame_2x1) { test_ChannelFrameTransmitter<2,1>(); } + TEST(ChannelFrameTransmitter, OutputFrame_2x16) { test_ChannelFrameTransmitter<2,16>(); } + TEST(ChannelFrameTransmitter, OutputFrame_2x256) { test_ChannelFrameTransmitter<2,256>(); } + TEST(ChannelFrameTransmitter, OutputFrame_2x1024) { test_ChannelFrameTransmitter<2,1024>(); } + + TEST(ChannelFrameTransmitter, OutputFrame_4x1) { test_ChannelFrameTransmitter<4,1>(); } + TEST(ChannelFrameTransmitter, OutputFrame_4x16) { test_ChannelFrameTransmitter<4,16>(); } + TEST(ChannelFrameTransmitter, OutputFrame_4x256) { test_ChannelFrameTransmitter<4,256>(); } + TEST(ChannelFrameTransmitter, OutputFrame_4x1024) { test_ChannelFrameTransmitter<4,1024>(); } + +} \ No newline at end of file diff --git a/tests/unit/src/test_DcoeSampleFilter.cpp b/tests/unit/src/test_DcoeSampleFilter.cpp new file mode 100644 index 00000000..4c259179 --- /dev/null +++ b/tests/unit/src/test_DcoeSampleFilter.cpp @@ -0,0 +1,92 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/dc_elimination.h" +#include "mic_array/cpp/SampleFilter.hpp" + +extern "C" { + +TEST_GROUP_RUNNER(DcoeSampleFilter) { + RUN_TEST_CASE(DcoeSampleFilter, states1); + RUN_TEST_CASE(DcoeSampleFilter, states4); + RUN_TEST_CASE(DcoeSampleFilter, states8); + RUN_TEST_CASE(DcoeSampleFilter, states32); +} + +TEST_GROUP(DcoeSampleFilter); +TEST_SETUP(DcoeSampleFilter) {} +TEST_TEAR_DOWN(DcoeSampleFilter) {} + +} + +// This extension is just a way to make the state accessible +template +class TestDcoeSampleFilter : public mic_array::DcoeSampleFilter +{ + public: + TestDcoeSampleFilter() : mic_array::DcoeSampleFilter() {} + dcoe_chan_state_t GetState(unsigned channel) { + return this->state[channel]; + } +}; + +template +static +void test_DcoeSampleFilter() +{ + + srand(7685664); + + TestDcoeSampleFilter filter; + int32_t input[CHANS]; + + double f_states[CHANS]; + + filter.Init(); + + for(int k = 0; k < CHANS; k++) f_states[k] = 0.0; + + for(int r = 0; r < ITER_COUNT; r++){ + + double f_output[CHANS]; + int32_t expected[CHANS]; + + for(int k = 0; k < CHANS; k++) + input[k] = rand(); + + // y[t] = (255.0/256) * y[t-1] - x[t-1] + x[t] + for(int k = 0; k < CHANS; k++){ + f_output[k] = f_states[k] + input[k]; + expected[k] = (int32_t) round(f_output[k]); + } + + filter.Filter(input); + + TEST_ASSERT_EQUAL_INT32_ARRAY(expected, input, CHANS); + + // If we don't pin the float state to the int state they will diverge. This + // isn't ideal because it means we're not really testing a whole lot, but we + // can improve the test cases later. + for(int k = 0; k < CHANS; k++) + f_states[k] = filter.GetState(k).prev_y >> 32; + + } +} + +extern "C" { + +TEST(DcoeSampleFilter, states1) { test_DcoeSampleFilter<1,1000>(); } +TEST(DcoeSampleFilter, states4) { test_DcoeSampleFilter<4,1000>(); } +TEST(DcoeSampleFilter, states8) { test_DcoeSampleFilter<8,1000>(); } +TEST(DcoeSampleFilter, states32) { test_DcoeSampleFilter<32,1000>(); } + +} \ No newline at end of file diff --git a/tests/unit/src/test_FrameOutputHandler.cpp b/tests/unit/src/test_FrameOutputHandler.cpp new file mode 100644 index 00000000..b414effb --- /dev/null +++ b/tests/unit/src/test_FrameOutputHandler.cpp @@ -0,0 +1,180 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/cpp/OutputHandler.hpp" + +extern "C" { + + TEST_GROUP_RUNNER(FrameOutputHandler) { + RUN_TEST_CASE(FrameOutputHandler, case_1x1); + RUN_TEST_CASE(FrameOutputHandler, case_1x16); + RUN_TEST_CASE(FrameOutputHandler, case_1x256); + RUN_TEST_CASE(FrameOutputHandler, case_1x1024); + RUN_TEST_CASE(FrameOutputHandler, case_2x1); + RUN_TEST_CASE(FrameOutputHandler, case_2x16); + RUN_TEST_CASE(FrameOutputHandler, case_2x256); + RUN_TEST_CASE(FrameOutputHandler, case_2x1024); + RUN_TEST_CASE(FrameOutputHandler, case_4x1); + RUN_TEST_CASE(FrameOutputHandler, case_4x16); + RUN_TEST_CASE(FrameOutputHandler, case_4x256); + RUN_TEST_CASE(FrameOutputHandler, case_4x1024); + + RUN_TEST_CASE(FrameOutputHandler, multibuffer); + } + + TEST_GROUP(FrameOutputHandler); + TEST_SETUP(FrameOutputHandler) {} + TEST_TEAR_DOWN(FrameOutputHandler) {} + +} + +template +class MockFrameTransmitter +{ + public: + + unsigned OutputFrame_called = 0; + + int32_t last_frame[MIC_COUNT][SAMPLE_COUNT]; + int32_t* last_frame_ptr; + + MockFrameTransmitter() {} + + void OutputFrame(int32_t frame[MIC_COUNT][SAMPLE_COUNT]) + { + OutputFrame_called++; + memcpy(&last_frame[0][0], &frame[0][0], sizeof(last_frame)); + last_frame_ptr = &frame[0][0]; + } +}; + + +template +static +void test_FrameOutputHandler() +{ + srand(45634*CHANS + SAMPLE_COUNT); + + constexpr unsigned LOOP_COUNT=400; + + using TFrameOutputHandler = mic_array::FrameOutputHandler; + + TFrameOutputHandler handler; + + for(int r = 0; r < LOOP_COUNT; r++){ + + TEST_ASSERT_EQUAL(r, handler.FrameTx.OutputFrame_called); + + int32_t exp_frame[CHANS][SAMPLE_COUNT]; + + for(int s = 0; s < SAMPLE_COUNT; s++){ + + int32_t sample[CHANS]; + for(int c = 0; c < CHANS; c++){ + sample[c] = rand(); + exp_frame[c][s] = sample[c]; + } + + handler.OutputSample(sample); + + if(s != SAMPLE_COUNT-1) + TEST_ASSERT_EQUAL(r, handler.FrameTx.OutputFrame_called); + else + TEST_ASSERT_EQUAL(r+1, handler.FrameTx.OutputFrame_called); + } + + TEST_ASSERT_EQUAL_INT32_ARRAY(&exp_frame[0][0], &handler.FrameTx.last_frame[0][0], CHANS * SAMPLE_COUNT); + + } +} + +extern "C" { + + TEST(FrameOutputHandler, case_1x1) { test_FrameOutputHandler<1,1>(); } + TEST(FrameOutputHandler, case_1x16) { test_FrameOutputHandler<1,16>(); } + TEST(FrameOutputHandler, case_1x256) { test_FrameOutputHandler<1,256>(); } + TEST(FrameOutputHandler, case_1x1024) { test_FrameOutputHandler<1,1024>(); } + TEST(FrameOutputHandler, case_2x1) { test_FrameOutputHandler<2,1>(); } + TEST(FrameOutputHandler, case_2x16) { test_FrameOutputHandler<2,16>(); } + TEST(FrameOutputHandler, case_2x256) { test_FrameOutputHandler<2,256>(); } + TEST(FrameOutputHandler, case_2x1024) { test_FrameOutputHandler<2,1024>(); } + TEST(FrameOutputHandler, case_4x1) { test_FrameOutputHandler<4,1>(); } + TEST(FrameOutputHandler, case_4x16) { test_FrameOutputHandler<4,16>(); } + TEST(FrameOutputHandler, case_4x256) { test_FrameOutputHandler<4,256>(); } + TEST(FrameOutputHandler, case_4x1024) { test_FrameOutputHandler<4,1024>(); } +} + + +template +static +void test_FrameOutputHandlerB() +{ + +} + +extern "C" { + + TEST(FrameOutputHandler, multibuffer) + { + constexpr unsigned CHANS = 1; + constexpr unsigned SAMPLE_COUNT = 16; + constexpr unsigned FRAME_COUNT = 4; + + srand(56456*CHANS + SAMPLE_COUNT); + + using TFrameOutputHandler = mic_array::FrameOutputHandler; + + TFrameOutputHandler handler; + + int32_t exp_frame[CHANS][SAMPLE_COUNT]; + + TEST_ASSERT_EQUAL(0, handler.FrameTx.OutputFrame_called); + + for(int s = 0; s < SAMPLE_COUNT; s++){ + int32_t sample[CHANS]; + for(int c = 0; c < CHANS; c++){ + sample[c] = rand(); + exp_frame[c][s] = sample[c]; + } + handler.OutputSample(sample); + } + + TEST_ASSERT_EQUAL(1, handler.FrameTx.OutputFrame_called); + + TEST_ASSERT_EQUAL_INT32_ARRAY(&exp_frame[0][0], handler.FrameTx.last_frame_ptr, CHANS * SAMPLE_COUNT); + + // If FRAME_COUNT had been 1, any more calls to OutputSample() would start overwriting the first frame. + auto* first_frame_ptr = handler.FrameTx.last_frame_ptr; + + int32_t sample_0x55[CHANS]; + for(int c = 0; c < CHANS; c++) + sample_0x55[c] = 0x55555555; + + for(int f = 0; f < (FRAME_COUNT-1); f++){ + for(int s = 0; s < SAMPLE_COUNT; s++){ + handler.OutputSample(sample_0x55); + } + + TEST_ASSERT_EQUAL_INT32_ARRAY(&exp_frame[0][0], first_frame_ptr, CHANS * SAMPLE_COUNT); + } + + // Any more output samples should overwrite the first frame + TEST_ASSERT_NOT_EQUAL_INT32(sample_0x55[0], first_frame_ptr[0]); + handler.OutputSample(sample_0x55); + TEST_ASSERT_EQUAL_INT32(sample_0x55[0], first_frame_ptr[0]); + + } + +} \ No newline at end of file diff --git a/tests/unit/src/test_dcoe_filter.cpp b/tests/unit/src/test_dcoe_filter.cpp new file mode 100644 index 00000000..aac51de9 --- /dev/null +++ b/tests/unit/src/test_dcoe_filter.cpp @@ -0,0 +1,82 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/dc_elimination.h" +#include "mic_array/cpp/SampleFilter.hpp" + +extern "C" { + +TEST_GROUP_RUNNER(dcoe_filter) { + RUN_TEST_CASE(dcoe_filter, states1); + RUN_TEST_CASE(dcoe_filter, states4); + RUN_TEST_CASE(dcoe_filter, states8); + RUN_TEST_CASE(dcoe_filter, states32); +} + +TEST_GROUP(dcoe_filter); +TEST_SETUP(dcoe_filter) {} +TEST_TEAR_DOWN(dcoe_filter) {} + +} + + +template +static +void test_dcoe_filter() +{ + + srand(7685664); + + dcoe_chan_state_t states[CHANS]; + int32_t input[CHANS]; + + double f_states[CHANS]; + + dcoe_state_init(states, CHANS); + for(int k = 0; k < CHANS; k++) f_states[k] = 0.0; + + for(int r = 0; r < ITER_COUNT; r++){ + + int32_t output[CHANS]; + double f_output[CHANS]; + int32_t expected[CHANS]; + + for(int k = 0; k < CHANS; k++) + input[k] = rand(); + + // y[t] = (255.0/256) * y[t-1] - x[t-1] + x[t] + for(int k = 0; k < CHANS; k++){ + f_output[k] = f_states[k] + input[k]; + expected[k] = (int32_t) round(f_output[k]); + } + + dcoe_filter(output, states, input, CHANS); + + TEST_ASSERT_EQUAL_INT32_ARRAY(expected, output, CHANS); + + // If we don't pin the float state to the int state they will diverge. This + // isn't ideal because it means we're not really testing a whole lot, but we + // can improve the test cases later. + for(int k = 0; k < CHANS; k++) + f_states[k] = states[k].prev_y >> 32; + + } +} + +extern "C" { + +TEST(dcoe_filter, states1) { test_dcoe_filter<1,1000>(); } +TEST(dcoe_filter, states4) { test_dcoe_filter<4,1000>(); } +TEST(dcoe_filter, states8) { test_dcoe_filter<8,1000>(); } +TEST(dcoe_filter, states32) { test_dcoe_filter<32,1000>(); } + +} \ No newline at end of file diff --git a/tests/unit/src/test_dcoe_state_init.cpp b/tests/unit/src/test_dcoe_state_init.cpp new file mode 100644 index 00000000..0d3eb3a6 --- /dev/null +++ b/tests/unit/src/test_dcoe_state_init.cpp @@ -0,0 +1,64 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/dc_elimination.h" +#include "mic_array/cpp/SampleFilter.hpp" + +extern "C" { + +TEST_GROUP_RUNNER(dcoe_state_init) { + RUN_TEST_CASE(dcoe_state_init, dcoe_state_init); +} + +TEST_GROUP(dcoe_state_init); +TEST_SETUP(dcoe_state_init) {} +TEST_TEAR_DOWN(dcoe_state_init) {} + +} + + +extern "C" { + +/** + * Currently initialization is just zeroing out the states. + */ +TEST(dcoe_state_init, dcoe_state_init) +{ + constexpr unsigned MAX_STATES = 400; + constexpr unsigned LOOP_COUNT = 4000; + + srand(57355544); + + dcoe_chan_state_t states[MAX_STATES]; + + auto* start_state = &states[1]; + + for(int r = 0; r < LOOP_COUNT; r++){ + + memset(states, 0x55, sizeof(states)); + + auto stateA = states[0]; + + unsigned N = rand() % (MAX_STATES-2); + + dcoe_state_init(start_state, N); + + TEST_ASSERT_EQUAL_INT64(stateA.prev_y, states[0].prev_y); + TEST_ASSERT_EQUAL_INT64(stateA.prev_y, states[N+1].prev_y); + + for(int k = 0; k < N; k++){ + TEST_ASSERT_EQUAL_INT64(0, start_state[k].prev_y); + } + } +} + +} \ No newline at end of file diff --git a/tests/unit/src/test_deinterleave2.c b/tests/unit/src/test_deinterleave2.c new file mode 100644 index 00000000..78068c0a --- /dev/null +++ b/tests/unit/src/test_deinterleave2.c @@ -0,0 +1,120 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/util.h" + +#define CHAN_COUNT 2 + +TEST_GROUP_RUNNER(deinterleave2) { + RUN_TEST_CASE(deinterleave2, case0); + RUN_TEST_CASE(deinterleave2, case1); +} + +TEST_GROUP(deinterleave2); +TEST_SETUP(deinterleave2) {} +TEST_TEAR_DOWN(deinterleave2) {} + + +static char details1[200]; +static char details2[200]; + +static +void set_test_details(const uint32_t expected[CHAN_COUNT], + const uint32_t test_vect[CHAN_COUNT]) +{ + sprintf(details1, "Expected: 0x%08X, 0x%08X", (unsigned) expected[0], + (unsigned) expected[1]); + sprintf(details2, "Test Inputs: 0x%08X, 0x%08X", (unsigned) test_vect[0], + (unsigned) test_vect[1]); + UNITY_SET_DETAILS(details1, details2); +} + +static +void interleave2(uint32_t res[CHAN_COUNT], + const uint32_t orig[CHAN_COUNT]) +{ + uint32_t mic[CHAN_COUNT]; + memcpy(mic, orig, sizeof(uint32_t) * CHAN_COUNT); + memset(res, 0, sizeof(uint32_t) * CHAN_COUNT); + + for(int n = 0; n < CHAN_COUNT; n++){ + const unsigned p = CHAN_COUNT-1-n; + for(int k = 0; k < 32; k++){ + // printf("n = %d\n", n); + // printf("p = %d\n", p); + // printf("k = %d\n", k); + const unsigned mc = k % CHAN_COUNT; + // printf("mc = %u\n", mc); + uint32_t a = mic[mc] & 1; + // printf("a = %lu\n", a); + // printf("mic[%u] = 0x%08X", mc, (unsigned) mic[mc]); + mic[mc] = mic[mc] >> 1; + // printf(" --> 0x%08X\n", (unsigned) mic[mc]); + + // printf("res[%u] = 0x%08X", p, (unsigned) res[p]); + res[p] = (res[p] >> 1) & 0x7FFFFFFF; + res[p] = res[p] | (a * ((uint32_t)0x80000000)); + // printf(" --> 0x%08X\n", (unsigned) res[p]); + // printf("----\n"); + } + } +} + +TEST(deinterleave2, case0) +{ + uint32_t expected[CHAN_COUNT] = { + 0xAA00FFFF, + 0xFFFF0044, + }; + + uint32_t vals[CHAN_COUNT] = { + 0xEEEEAAAA, + 0x55557575, + }; + + set_test_details(expected, vals); + + deinterleave2(&vals[0]); + + TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, vals, CHAN_COUNT, ""); +} + + + +TEST(deinterleave2, case1) +{ + + srand(0x343467); + + uint32_t expected[CHAN_COUNT]; + uint32_t test_vect[CHAN_COUNT]; + + const unsigned LOOP_COUNT = 4000; + + for(int rep = 0; rep < LOOP_COUNT; rep++){ + + // Pick random inputs + for(int k = 0; k < CHAN_COUNT; k++) + expected[k] = rand(); + + // Interleave them + interleave2(test_vect, expected); + + set_test_details(expected, test_vect); + + // Deinterleave + deinterleave2(&test_vect[0]); + + // Check result + TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, test_vect, CHAN_COUNT, ""); + } +} \ No newline at end of file diff --git a/tests/unit/src/test_deinterleave4.c b/tests/unit/src/test_deinterleave4.c new file mode 100644 index 00000000..32c8be2a --- /dev/null +++ b/tests/unit/src/test_deinterleave4.c @@ -0,0 +1,116 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/util.h" + +#define CHAN_COUNT 4 + +TEST_GROUP_RUNNER(deinterleave4) { + RUN_TEST_CASE(deinterleave4, case0); + RUN_TEST_CASE(deinterleave4, case1); +} + +TEST_GROUP(deinterleave4); +TEST_SETUP(deinterleave4) {} +TEST_TEAR_DOWN(deinterleave4) {} + + +static char details1[200]; +static char details2[200]; + +static +void set_test_details(const uint32_t expected[CHAN_COUNT], + const uint32_t test_vect[CHAN_COUNT]) +{ + sprintf(details1, "Expected: 0x%08X, 0x%08X, 0x%08X, 0x%08X", + (unsigned) expected[0], (unsigned) expected[1], + (unsigned) expected[2], (unsigned) expected[3]); + sprintf(details2, "Test Inputs: 0x%08X, 0x%08X, 0x%08X, 0x%08X", + (unsigned) test_vect[0], (unsigned) test_vect[1], + (unsigned) test_vect[2], (unsigned) test_vect[3]); + UNITY_SET_DETAILS(details1, details2); +} + +static +void interleave4(uint32_t res[CHAN_COUNT], + const uint32_t orig[CHAN_COUNT]) +{ + uint32_t mic[CHAN_COUNT]; + memcpy(mic, orig, sizeof(uint32_t) * CHAN_COUNT); + memset(res, 0, sizeof(uint32_t) * CHAN_COUNT); + + for(int n = 0; n < CHAN_COUNT; n++){ + const unsigned p = CHAN_COUNT-1-n; + for(int k = 0; k < 32; k++){ + const unsigned mc = k % CHAN_COUNT; + uint32_t a = mic[mc] & 1; + mic[mc] = mic[mc] >> 1; + res[p] = (res[p] >> 1) & 0x7FFFFFFF; + res[p] = res[p] | (a * ((uint32_t)0x80000000)); + } + } +} + +TEST(deinterleave4, case0) +{ + + uint32_t expected[CHAN_COUNT] = { + 0x0000FFFF, + 0xFFFF0000, + 0x0F0F0F0F, + 0xF0F0F0F0, + }; + + uint32_t vals[CHAN_COUNT] = { + 0xAAAA6666, + 0xAAAA6666, + 0x99995555, + 0x99995555, + }; + + set_test_details(expected, vals); + + deinterleave4(&vals[0]); + + TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, vals, CHAN_COUNT, ""); +} + + + +TEST(deinterleave4, case1) +{ + + srand(0x343467); + + uint32_t expected[CHAN_COUNT]; + uint32_t test_vect[CHAN_COUNT]; + + const unsigned LOOP_COUNT = 4000; + + for(int rep = 0; rep < LOOP_COUNT; rep++){ + + // Pick random inputs + for(int k = 0; k < CHAN_COUNT; k++) + expected[k] = rand(); + + // Interleave them + interleave4(test_vect, expected); + + set_test_details(expected, test_vect); + + // Deinterleave + deinterleave4(&test_vect[0]); + + // Check result + TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, test_vect, CHAN_COUNT, ""); + } +} \ No newline at end of file diff --git a/tests/unit/src/test_deinterleave8.c b/tests/unit/src/test_deinterleave8.c new file mode 100644 index 00000000..889b9630 --- /dev/null +++ b/tests/unit/src/test_deinterleave8.c @@ -0,0 +1,126 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/util.h" + +#define CHAN_COUNT 8 + +TEST_GROUP_RUNNER(deinterleave8) { + RUN_TEST_CASE(deinterleave8, case0); + RUN_TEST_CASE(deinterleave8, case1); +} + +TEST_GROUP(deinterleave8); +TEST_SETUP(deinterleave8) {} +TEST_TEAR_DOWN(deinterleave8) {} + + +static char details1[200]; +static char details2[200]; + +static +void set_test_details(const uint32_t expected[CHAN_COUNT], + const uint32_t test_vect[CHAN_COUNT]) +{ + sprintf(details1, "Expected: 0x%08X, 0x%08X, 0x%08X, 0x%08X", + (unsigned) expected[0], (unsigned) expected[1], + (unsigned) expected[2], (unsigned) expected[3]); + sprintf(details2, "Test Inputs: 0x%08X, 0x%08X, 0x%08X, 0x%08X", + (unsigned) test_vect[0], (unsigned) test_vect[1], + (unsigned) test_vect[2], (unsigned) test_vect[3]); + UNITY_SET_DETAILS(details1, details2); +} + +static +void interleave8(uint32_t res[CHAN_COUNT], + const uint32_t orig[CHAN_COUNT]) +{ + uint32_t mic[CHAN_COUNT]; + memcpy(mic, orig, sizeof(uint32_t) * CHAN_COUNT); + memset(res, 0, sizeof(uint32_t) * CHAN_COUNT); + + for(int n = 0; n < CHAN_COUNT; n++){ + const unsigned p = CHAN_COUNT-1-n; + for(int k = 0; k < 32; k++){ + const unsigned mc = k % CHAN_COUNT; + uint32_t a = mic[mc] & 1; + mic[mc] = mic[mc] >> 1; + res[p] = (res[p] >> 1) & 0x7FFFFFFF; + res[p] = res[p] | (a * ((uint32_t)0x80000000)); + } + } +} + +TEST(deinterleave8, case0) +{ + + + uint32_t expected[CHAN_COUNT] = { + 0x0000FFFF, + 0xFFFF0000, + 0x0F0F0F0F, + 0xF0F0F0F0, + + 0x01234567, + 0x76543210, + 0x00000000, + 0xFFFFFFFF, + }; + + uint32_t vals[CHAN_COUNT] = { + 0x8AAAAAAA, + 0x86A6A696, + 0x8AAA9AAA, + 0x86A69696, + 0x8999A9A9, + 0x8595A595, + 0x899999A9, + 0x85959595, + }; + + set_test_details(expected, vals); + + deinterleave8(&vals[0]); + + TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, vals, CHAN_COUNT, ""); +} + + + +TEST(deinterleave8, case1) +{ + + srand(0x343467); + + uint32_t expected[CHAN_COUNT]; + uint32_t test_vect[CHAN_COUNT]; + + const unsigned LOOP_COUNT = 4000; + + for(int rep = 0; rep < LOOP_COUNT; rep++){ + + // Pick random inputs + for(int k = 0; k < CHAN_COUNT; k++) + expected[k] = rand(); + + // Interleave them + interleave8(test_vect, expected); + + set_test_details(expected, test_vect); + + // Deinterleave + deinterleave8(&test_vect[0]); + + // Check result + TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, test_vect, CHAN_COUNT, ""); + } +} \ No newline at end of file diff --git a/tests/unit/src/test_deinterleave_pdm_samples.cpp b/tests/unit/src/test_deinterleave_pdm_samples.cpp new file mode 100644 index 00000000..27a2f6a7 --- /dev/null +++ b/tests/unit/src/test_deinterleave_pdm_samples.cpp @@ -0,0 +1,198 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/cpp/Util.hpp" + +extern "C" { + +TEST_GROUP_RUNNER(deinterleave_pdm_samples) { + RUN_TEST_CASE(deinterleave_pdm_samples, interleave); + RUN_TEST_CASE(deinterleave_pdm_samples, chan1_sdf1); + RUN_TEST_CASE(deinterleave_pdm_samples, chan1_sdf3); + RUN_TEST_CASE(deinterleave_pdm_samples, chan1_sdf6); + RUN_TEST_CASE(deinterleave_pdm_samples, chan2_sdf1); + RUN_TEST_CASE(deinterleave_pdm_samples, chan2_sdf3); + RUN_TEST_CASE(deinterleave_pdm_samples, chan2_sdf6); + RUN_TEST_CASE(deinterleave_pdm_samples, chan4_sdf1); + RUN_TEST_CASE(deinterleave_pdm_samples, chan4_sdf4); + RUN_TEST_CASE(deinterleave_pdm_samples, chan4_sdf6); + RUN_TEST_CASE(deinterleave_pdm_samples, chan8_sdf1); + RUN_TEST_CASE(deinterleave_pdm_samples, chan8_sdf4); + RUN_TEST_CASE(deinterleave_pdm_samples, chan8_sdf6); +} + +TEST_GROUP(deinterleave_pdm_samples); +TEST_SETUP(deinterleave_pdm_samples) {} +TEST_TEAR_DOWN(deinterleave_pdm_samples) {} + +} + + +template +void interleave_pdm_samples(uint32_t test_vect[], + uint32_t expected[BLOCKS][CHAN_COUNT], + const uint32_t orig[CHAN_COUNT][BLOCKS]) +{ + uint32_t copy[CHAN_COUNT][BLOCKS]; + memcpy(copy, orig, sizeof(copy)); + + for(int b = 0; b < BLOCKS; b++){ + for(int c = 0; c < CHAN_COUNT; c++){ + expected[b][c] = orig[c][BLOCKS-1-b]; + } + } + + for(int i = CHAN_COUNT*BLOCKS-1; i >= 0; i--){ + + uint32_t& vect_word = test_vect[i]; + const unsigned b = BLOCKS - 1 - (i/CHAN_COUNT); + + for(int k = 0; k < 32; k++){ + const unsigned m = k % CHAN_COUNT; + uint32_t& orig_word = copy[m][b]; + uint32_t a = orig_word & 1; + orig_word = orig_word >> 1; + vect_word = (vect_word >> 1) & 0x7FFFFFFF; + vect_word = vect_word | (a * ((uint32_t)0x80000000)); + } + } + +} + +extern "C" { + +TEST(deinterleave_pdm_samples, interleave) +{ + if(1) { + constexpr unsigned CHAN_COUNT = 1; + constexpr unsigned BLOCKS = 1; + constexpr unsigned WORD_COUNT = CHAN_COUNT * BLOCKS; + + uint32_t original[CHAN_COUNT][BLOCKS] = {{ 0x12345678 }}; + uint32_t exp_expected[BLOCKS][CHAN_COUNT] = {{ 0x12345678 }}; + uint32_t exp_test_vect[BLOCKS][CHAN_COUNT] = {{ 0x12345678 }}; + + uint32_t expected[BLOCKS][CHAN_COUNT]; + uint32_t test_vect[BLOCKS][CHAN_COUNT]; + + interleave_pdm_samples(&test_vect[0][0], expected, original); + + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_expected[0][0], &expected[0][0], WORD_COUNT); + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_test_vect[0][0], &test_vect[0][0], WORD_COUNT); + } + + if(1) { + constexpr unsigned CHAN_COUNT = 2; + constexpr unsigned BLOCKS = 1; + constexpr unsigned WORD_COUNT = CHAN_COUNT * BLOCKS; + + uint32_t original[CHAN_COUNT][BLOCKS] = {{0x01234567},{0x89ABCDEF}}; + uint32_t exp_expected[BLOCKS][CHAN_COUNT] = {{0x01234567, 0x89ABCDEF}}; + uint32_t exp_test_vect[BLOCKS][CHAN_COUNT] = {{ 0x80838C8F, 0xB0B3BCBF }}; + + uint32_t expected[BLOCKS][CHAN_COUNT]; + uint32_t test_vect[BLOCKS][CHAN_COUNT]; + + interleave_pdm_samples(&test_vect[0][0], expected, original); + + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_expected[0][0], &expected[0][0], WORD_COUNT); + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_test_vect[0][0], &test_vect[0][0], WORD_COUNT); + } + + if(1) { + constexpr unsigned CHAN_COUNT = 1; + constexpr unsigned BLOCKS = 2; + constexpr unsigned WORD_COUNT = CHAN_COUNT * BLOCKS; + + uint32_t original[CHAN_COUNT][BLOCKS] = {{ 0x01234567, 0x89ABCDEF }}; + uint32_t exp_expected[BLOCKS][CHAN_COUNT] = {{0x89ABCDEF}, {0x01234567}}; + uint32_t exp_test_vect[BLOCKS][CHAN_COUNT] = {{0x89ABCDEF},{0x01234567}}; + + uint32_t expected[BLOCKS][CHAN_COUNT]; + uint32_t test_vect[BLOCKS][CHAN_COUNT]; + + interleave_pdm_samples(&test_vect[0][0], expected, original); + + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_expected[0][0], &expected[0][0], WORD_COUNT); + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_test_vect[0][0], &test_vect[0][0], WORD_COUNT); + } + + if(1) { + constexpr unsigned CHAN_COUNT = 2; + constexpr unsigned BLOCKS = 2; + constexpr unsigned WORD_COUNT = CHAN_COUNT * BLOCKS; + + uint32_t original[CHAN_COUNT][BLOCKS] = {{0x01234567,0xFF00FF00}, + {0x89ABCDEF,0x00FF00FF}}; + uint32_t exp_expected[BLOCKS][CHAN_COUNT] = {{0xFF00FF00,0x00FF00FF}, + {0x01234567,0x89ABCDEF}}; + uint32_t exp_test_vect[BLOCKS][CHAN_COUNT] = {{0x5555AAAA,0x5555AAAA}, + {0x80838C8F,0xB0B3BCBF}}; + + uint32_t expected[BLOCKS][CHAN_COUNT]; + uint32_t test_vect[BLOCKS][CHAN_COUNT]; + + interleave_pdm_samples(&test_vect[0][0], expected, original); + + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_expected[0][0], &expected[0][0], WORD_COUNT); + TEST_ASSERT_EQUAL_UINT32_ARRAY(&exp_test_vect[0][0], &test_vect[0][0], WORD_COUNT); + } +} + +} + +template +static +void test_deinterleave_pdm_samples() +{ + + uint32_t original[CHAN_COUNT][BLOCKS]; + uint32_t expected[BLOCKS][CHAN_COUNT]; + uint32_t test_vect[BLOCKS][CHAN_COUNT]; + + srand((CHAN_COUNT+97)*(BLOCKS*57)+0x5463); + + static constexpr unsigned LOOP_COUNT = 4000; + + for(int r = 0; r < LOOP_COUNT; r++){ + + for(int c = 0; c < CHAN_COUNT; c++) + for(int b = 0; b < BLOCKS; b++) + original[c][b] = rand(); + + interleave_pdm_samples(&test_vect[0][0], expected, original); + + mic_array::deinterleave_pdm_samples(&test_vect[0][0], BLOCKS); + + TEST_ASSERT_EQUAL_UINT32_ARRAY(&expected[0][0], &test_vect[0][0], + CHAN_COUNT * BLOCKS); + } +} + +extern "C" { + +TEST(deinterleave_pdm_samples, chan1_sdf1) { test_deinterleave_pdm_samples<1,1>(); } +TEST(deinterleave_pdm_samples, chan1_sdf3) { test_deinterleave_pdm_samples<1,3>(); } +TEST(deinterleave_pdm_samples, chan1_sdf6) { test_deinterleave_pdm_samples<1,6>(); } +TEST(deinterleave_pdm_samples, chan2_sdf1) { test_deinterleave_pdm_samples<2,1>(); } +TEST(deinterleave_pdm_samples, chan2_sdf3) { test_deinterleave_pdm_samples<2,3>(); } +TEST(deinterleave_pdm_samples, chan2_sdf6) { test_deinterleave_pdm_samples<2,6>(); } +TEST(deinterleave_pdm_samples, chan4_sdf1) { test_deinterleave_pdm_samples<4,1>(); } +TEST(deinterleave_pdm_samples, chan4_sdf4) { test_deinterleave_pdm_samples<4,4>(); } +TEST(deinterleave_pdm_samples, chan4_sdf6) { test_deinterleave_pdm_samples<4,6>(); } +TEST(deinterleave_pdm_samples, chan8_sdf1) { test_deinterleave_pdm_samples<8,1>(); } +TEST(deinterleave_pdm_samples, chan8_sdf4) { test_deinterleave_pdm_samples<8,4>(); } +TEST(deinterleave_pdm_samples, chan8_sdf6) { test_deinterleave_pdm_samples<8,6>(); } + + + +} \ No newline at end of file diff --git a/tests/unit/src/test_ma_frame_tx_rx.cpp b/tests/unit/src/test_ma_frame_tx_rx.cpp new file mode 100644 index 00000000..f5f1d158 --- /dev/null +++ b/tests/unit/src/test_ma_frame_tx_rx.cpp @@ -0,0 +1,111 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/frame_transfer.h" + +extern "C" { + + static + struct { + channel_t c_frames; + } rx_ctx; + + TEST_GROUP_RUNNER(ma_frame_tx_rx) { + RUN_TEST_CASE(ma_frame_tx_rx, case_1chan_1samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_1chan_16samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_1chan_256samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_1chan_1024samp); + + RUN_TEST_CASE(ma_frame_tx_rx, case_2chan_1samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_2chan_16samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_2chan_256samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_2chan_1024samp); + + RUN_TEST_CASE(ma_frame_tx_rx, case_4chan_1samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_4chan_16samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_4chan_256samp); + RUN_TEST_CASE(ma_frame_tx_rx, case_4chan_1024samp); + } + + TEST_GROUP(ma_frame_tx_rx); + + TEST_SETUP(ma_frame_tx_rx) { + rx_ctx.c_frames = chan_alloc(); + } + + TEST_TEAR_DOWN(ma_frame_tx_rx) { + chan_free(rx_ctx.c_frames); + } + + + static unsigned stack[8000]; + static void* stack_start = stack_base(stack, 8000); + +} + +template +static void send_frame(void* vframe) +{ + int32_t* frame = (int32_t*) vframe; + + // Send the frame we were told to send + ma_frame_tx(rx_ctx.c_frames.end_a, frame, CHANS, SAMPLE_COUNT); + +} + +template +static +void test_ma_frame_tx_rx() +{ + srand(7685664*CHANS + SAMPLE_COUNT); + + constexpr unsigned LOOP_COUNT=400; + + for(int r = 0; r < LOOP_COUNT; r++){ + int32_t exp_frame[CHANS][SAMPLE_COUNT]; + + for(int c = 0; c < CHANS; c++) + for(int s = 0; s < SAMPLE_COUNT; s++) + exp_frame[c][s] = rand(); + + run_async( send_frame, &exp_frame[0][0], stack_start); + + int32_t received[CHANS][SAMPLE_COUNT]; + + ma_frame_rx(&received[0][0], rx_ctx.c_frames.end_b, CHANS, SAMPLE_COUNT); + + TEST_ASSERT_EQUAL_INT32_ARRAY(&exp_frame[0][0], &received[0][0], CHANS * SAMPLE_COUNT); + } +} + +extern "C" { + + TEST(ma_frame_tx_rx, case_1chan_1samp) { test_ma_frame_tx_rx<1,1>(); } + TEST(ma_frame_tx_rx, case_1chan_16samp) { test_ma_frame_tx_rx<1,16>(); } + TEST(ma_frame_tx_rx, case_1chan_256samp) { test_ma_frame_tx_rx<1,256>(); } + TEST(ma_frame_tx_rx, case_1chan_1024samp) { test_ma_frame_tx_rx<1,1024>(); } + + TEST(ma_frame_tx_rx, case_2chan_1samp) { test_ma_frame_tx_rx<2,1>(); } + TEST(ma_frame_tx_rx, case_2chan_16samp) { test_ma_frame_tx_rx<2,16>(); } + TEST(ma_frame_tx_rx, case_2chan_256samp) { test_ma_frame_tx_rx<2,256>(); } + TEST(ma_frame_tx_rx, case_2chan_1024samp) { test_ma_frame_tx_rx<2,1024>(); } + + TEST(ma_frame_tx_rx, case_4chan_1samp) { test_ma_frame_tx_rx<4,1>(); } + TEST(ma_frame_tx_rx, case_4chan_16samp) { test_ma_frame_tx_rx<4,16>(); } + TEST(ma_frame_tx_rx, case_4chan_256samp) { test_ma_frame_tx_rx<4,256>(); } + TEST(ma_frame_tx_rx, case_4chan_1024samp) { test_ma_frame_tx_rx<4,1024>(); } + +} \ No newline at end of file diff --git a/tests/unit/src/test_ma_frame_tx_rx_transpose.cpp b/tests/unit/src/test_ma_frame_tx_rx_transpose.cpp new file mode 100644 index 00000000..06d49ac1 --- /dev/null +++ b/tests/unit/src/test_ma_frame_tx_rx_transpose.cpp @@ -0,0 +1,128 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "unity_fixture.h" + +#include "mic_array/frame_transfer.h" + +extern "C" { + + static + struct { + channel_t c_frames; + } rx_ctx; + + TEST_GROUP_RUNNER(ma_frame_tx_rx_transpose) { + + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_1chan_1samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_1chan_16samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_1chan_256samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_1chan_1024samp); + + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_2chan_1samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_2chan_16samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_2chan_256samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_2chan_1024samp); + + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_4chan_1samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_4chan_16samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_4chan_256samp); + RUN_TEST_CASE(ma_frame_tx_rx_transpose, case_4chan_1024samp); + } + + TEST_GROUP(ma_frame_tx_rx_transpose); + + TEST_SETUP(ma_frame_tx_rx_transpose) { + rx_ctx.c_frames = chan_alloc(); + } + + TEST_TEAR_DOWN(ma_frame_tx_rx_transpose) { + chan_free(rx_ctx.c_frames); + } + + + static unsigned stack[8000]; + static void* stack_start = stack_base(stack, 8000); + +} + +template +static void send_frame(void* vframe) +{ + int32_t* frame = (int32_t*) vframe; + + // Send the frame we were told to send + ma_frame_tx(rx_ctx.c_frames.end_a, frame, CHANS, SAMPLE_COUNT); + +} + +static +char details[2][200]; + +static +void set_test_details(unsigned iter) +{ + sprintf(details[0], "[ITER: %u]", iter); + UNITY_SET_DETAIL(&details[0][0]); +} + + +template +static +void test_ma_frame_tx_rx_transpose() +{ + srand(7685664*CHANS + SAMPLE_COUNT); + + constexpr unsigned LOOP_COUNT=400; + + for(int r = 0; r < LOOP_COUNT; r++){ + set_test_details(r); + int32_t tx_frame[CHANS][SAMPLE_COUNT]; + int32_t exp_frame[SAMPLE_COUNT][CHANS]; + + for(int c = 0; c < CHANS; c++) { + for(int s = 0; s < SAMPLE_COUNT; s++) { + tx_frame[c][s] = rand(); + exp_frame[s][c] = tx_frame[c][s]; + } + } + + run_async( send_frame, &tx_frame[0][0], stack_start); + + int32_t received[SAMPLE_COUNT][CHANS]; + + ma_frame_rx_transpose(&received[0][0], rx_ctx.c_frames.end_b, CHANS, SAMPLE_COUNT); + + TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(&exp_frame[0][0], &received[0][0], CHANS * SAMPLE_COUNT, ""); + } +} + +extern "C" { + + TEST(ma_frame_tx_rx_transpose, case_1chan_1samp) { test_ma_frame_tx_rx_transpose<1,1>(); } + TEST(ma_frame_tx_rx_transpose, case_1chan_16samp) { test_ma_frame_tx_rx_transpose<1,16>(); } + TEST(ma_frame_tx_rx_transpose, case_1chan_256samp) { test_ma_frame_tx_rx_transpose<1,256>(); } + TEST(ma_frame_tx_rx_transpose, case_1chan_1024samp) { test_ma_frame_tx_rx_transpose<1,1024>(); } + + TEST(ma_frame_tx_rx_transpose, case_2chan_1samp) { test_ma_frame_tx_rx_transpose<2,1>(); } + TEST(ma_frame_tx_rx_transpose, case_2chan_16samp) { test_ma_frame_tx_rx_transpose<2,16>(); } + TEST(ma_frame_tx_rx_transpose, case_2chan_256samp) { test_ma_frame_tx_rx_transpose<2,256>(); } + TEST(ma_frame_tx_rx_transpose, case_2chan_1024samp) { test_ma_frame_tx_rx_transpose<2,1024>(); } + + TEST(ma_frame_tx_rx_transpose, case_4chan_1samp) { test_ma_frame_tx_rx_transpose<4,1>(); } + TEST(ma_frame_tx_rx_transpose, case_4chan_16samp) { test_ma_frame_tx_rx_transpose<4,16>(); } + TEST(ma_frame_tx_rx_transpose, case_4chan_256samp) { test_ma_frame_tx_rx_transpose<4,256>(); } + TEST(ma_frame_tx_rx_transpose, case_4chan_1024samp) { test_ma_frame_tx_rx_transpose<4,1024>(); } + +} \ No newline at end of file diff --git a/tests/unit/src/unity_config.h b/tests/unit/src/unity_config.h new file mode 100644 index 00000000..a1108b52 --- /dev/null +++ b/tests/unit/src/unity_config.h @@ -0,0 +1,12 @@ +// Copyright 2020-2022 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. +#pragma once + +#define UNITY_SUPPORT_64 1 + +// Prevents Unity from taking control of malloc() and free() +#define UNITY_FIXTURE_NO_EXTRAS (1) + + +#define UNITY_DETAIL1_NAME "" +#define UNITY_DETAIL2_NAME "" \ No newline at end of file diff --git a/tests/unit_tests/config.xscope b/tests/unit_tests/config.xscope deleted file mode 100644 index bfdf1f86..00000000 --- a/tests/unit_tests/config.xscope +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - diff --git a/tests/unit_tests/conftest.py b/tests/unit_tests/conftest.py deleted file mode 100644 index 80fdda5e..00000000 --- a/tests/unit_tests/conftest.py +++ /dev/null @@ -1,116 +0,0 @@ -# Copyright 2018-2021 XMOS LIMITED. -# This Software is subject to the terms of the XMOS Public Licence: Version 1. -import os.path -import pytest -import subprocess - - -def pytest_collect_file(parent, path): - # TODO: get UNITY_TEST_PREFIX and UNITY_RUNNER_SUFFIX from wscript - # or from a shared unity config file - if ((path.ext == ".c" or path.ext == ".xc") - and (path.basename.startswith("test_") - and "_Runner" not in path.basename)): - return UnityTestSource.from_parent(parent, fspath=path) - - -class UnityTestSource(pytest.File): - def collect(self): - # Find the binary built from the runner for this test file - # - # Assume the following directory layout: - # unit_tests/ <- Test root directory - # |-- bin/ <- Compiled binaries of the test runners - # |-- conftest.py <- This file - # |-- runners/ <- Auto-generated buildable source of test binaries - # |-- src/ <- Unity test functions - # `-- wscript <- Build system file used to generate/build runners - test_root_dir_name = os.path.basename(os.path.dirname(__file__)) - test_src_path = os.path.basename(str(self.fspath)) - test_src_name = os.path.splitext(test_src_path)[0] - - test_bin_name_si = os.path.join( - test_src_name + '_single_issue.xe') - test_bin_path_si = os.path.join('bin', - test_bin_name_si) - yield UnityTestExecutable.from_parent(self, name=test_bin_path_si) - - test_bin_name_di = os.path.join( - test_src_name + '_dual_issue.xe') - test_bin_path_di = os.path.join('bin', - test_bin_name_di) - yield UnityTestExecutable.from_parent(self, name=test_bin_path_di) - - -class UnityTestExecutable(pytest.Item): - def __init__(self, name, parent): - super(UnityTestExecutable, self).__init__(name, parent) - self._nodeid = self.name # Override the naming to suit C better - - def runtest(self): - # Run the binary in the simulator - simulator_fail = False - test_output = None - try: - test_output = subprocess.check_output(['axe', self.name], text=True) - except subprocess.CalledProcessError as e: - # Unity exits non-zero if an assertion fails - simulator_fail = True - test_output = e.output - - # Parse the Unity output - unity_pass = False - test_output = test_output.split('\n') - for line in test_output: - if line.startswith(self.parent.name): - test_report = line.split(':') - # Unity output is as follows: - # :::PASS - # :::FAIL: - test_source = test_report[0] - line_number = test_report[1] - test_case = test_report[2] - result = test_report[3] - failure_reason = None - print('\n {}()'.format(test_case)), - if result == 'PASS': - unity_pass = True - continue - if result == 'FAIL': - failure_reason = test_report[4] - print('') # Insert line break after test_case print - raise UnityTestException(self, {'test_source': test_source, - 'line_number': line_number, - 'test_case': test_case, - 'failure_reason': - failure_reason}) - - if simulator_fail: - raise Exception(self, "Simulation failed.") - if not unity_pass: - raise Exception(self, "Unity test output not found.") - print('') # Insert line break after final test_case which passed - - def repr_failure(self, excinfo): - if isinstance(excinfo.value, UnityTestException): - return '\n'.join([str(self.parent).strip('<>'), - '{}:{}:{}()'.format( - excinfo.value[1]['test_source'], - excinfo.value[1]['line_number'], - excinfo.value[1]['test_case']), - 'Failure reason:', - excinfo.value[1]['failure_reason']]) - else: - return str(excinfo.value) - - def reportinfo(self): - # It's not possible to give sensible line number info for an executable - # so we return it as 0. - # - # The source line number will instead be recovered from the Unity print - # statements. - return self.fspath, 0, self.name - - -class UnityTestException(Exception): - pass diff --git a/tests/unit_tests/generate_output/Makefile b/tests/unit_tests/generate_output/Makefile deleted file mode 100644 index e1e5a2d2..00000000 --- a/tests/unit_tests/generate_output/Makefile +++ /dev/null @@ -1,18 +0,0 @@ -# The TARGET variable determines what target system the application is -# compiled for. It either refers to an XN file in the source directories -# or a valid argument for the --target option when compiling -TARGET = XCORE-200-EXPLORER - -# The APP_NAME variable determines the name of the final .xe file. It should -# not include the .xe postfix. If left blank the name will default to -# the project name -APP_NAME = generate_output - -# The USED_MODULES variable lists other modules used by the application. -USED_MODULES = lib_mic_array - -# The flags passed to xcc when building the application -XCC_FLAGS = -O2 -g - -XMOS_MAKE_PATH ?= ../.. --include $(XMOS_MAKE_PATH)/xcommon/module_xcommon/build/Makefile.common diff --git a/tests/unit_tests/generate_output/frontend_debug.h b/tests/unit_tests/generate_output/frontend_debug.h deleted file mode 100644 index f8400e5b..00000000 --- a/tests/unit_tests/generate_output/frontend_debug.h +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright 2017-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. - - -#ifdef __XC__ -#include "mic_array.h" - -void push_random_data(streaming chanend c_pdm_mics); -void audio_frontend_debug_1_dc_no_ref(streaming chanend c_not_a_port, - streaming chanend c_ds_output[]); -void receive_from_mics_init(streaming chanend c_mics[]); -mic_array_frame_time_domain * unsafe get_next_frame(streaming chanend c_mics[]); -void setup_mic_array_decimator(mic_array_decimator_conf_common_t &decimator_common_config, - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS], - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]); - -#endif diff --git a/tests/unit_tests/generate_output/frontend_debug.xc b/tests/unit_tests/generate_output/frontend_debug.xc deleted file mode 100644 index cc6bd88c..00000000 --- a/tests/unit_tests/generate_output/frontend_debug.xc +++ /dev/null @@ -1,65 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include "mic_array.h" - -#define CRC_POLY (0xEB31D82E) - -void pdm_rx_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -void push_random_data(streaming chanend c_pdm_mics) { - unsigned x = 1234; - while (1) { - crc32(x, -1, CRC_POLY); - c_pdm_mics <: x; - } -} - -void audio_frontend_debug_1_dc_no_ref(streaming chanend c_not_a_port, - streaming chanend c_ds_output[]) { - streaming chan c_4x_pdm_mic; - - par { - pdm_rx_debug(c_not_a_port, c_4x_pdm_mic, NULL); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic, c_ds_output[0], NULL); - } -} - -void setup_mic_array_decimator(mic_array_decimator_conf_common_t &decimator_common_config, - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS], - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]) { - unsafe { -#if MIC_ARRAY_FRAME_SIZE < 16 -// Comment taken from mic_array.h -/**< If len is less than 16 then this sets the frame size to 2 to the power of len, i.e. A frame will contain 2 to the power of len samples of each channel. - If len is 16 or greater then the frame size is equal to len. */ - - decimator_common_config.len = MIC_ARRAY_MAX_FRAME_SIZE_LOG2; -#else - decimator_common_config.len = MIC_ARRAY_FRAME_SIZE; -#endif - decimator_common_config.apply_dc_offset_removal = 1; - decimator_common_config.index_bit_reversal = 0; - decimator_common_config.windowing_function = null; - decimator_common_config.output_decimation_factor = MIC_DECIMATION_FACTOR; - decimator_common_config.coefs = g_third_stage_div_6_fir; // 16kHz - decimator_common_config.apply_mic_gain_compensation = 0; - decimator_common_config.fir_gain_compensation = FIR_COMPENSATOR_DIV_6; // 16kHz - decimator_common_config.buffering_type = DECIMATOR_NO_FRAME_OVERLAP; - decimator_common_config.number_of_frame_buffers = MIC_FRAME_BUFFERS; - - decimator_config[0].dcc = &decimator_common_config; - decimator_config[0].data = mic_array_data[0]; - decimator_config[0].mic_gain_compensation[0]=0; - decimator_config[0].mic_gain_compensation[1]=0; - decimator_config[0].mic_gain_compensation[2]=0; - decimator_config[0].mic_gain_compensation[3]=0; - decimator_config[0].channel_count = MIC_CHANNELS; - decimator_config[0].async_interface_enabled = 0; - } -} diff --git a/tests/unit_tests/generate_output/generate_output.xc b/tests/unit_tests/generate_output/generate_output.xc deleted file mode 100644 index 387134e0..00000000 --- a/tests/unit_tests/generate_output/generate_output.xc +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include "math.h" -#include "string.h" -#include "stdlib.h" -#include "mic_array.h" -#include "frontend_debug.h" - -#include -#include -#include - - -int main() { - streaming chan c_pdm_mics; - streaming chan c_ds_output[1]; - - // Mic array state - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - unsigned mic_buffer_index = 0; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - mic_array_decimator_conf_common_t decimator_common_config; - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS]; - - par { - audio_frontend_debug_1_dc_no_ref(c_pdm_mics, c_ds_output); - push_random_data(c_pdm_mics); - { - setup_mic_array_decimator(decimator_common_config, decimator_config, - mic_array_data); - mic_array_decimator_configure(c_ds_output, - MIC_DECIMATORS, - decimator_config); - mic_array_init_time_domain_frame(c_ds_output, - MIC_DECIMATORS, - mic_buffer_index, - audio_frame, - decimator_config); - - // Skip the first 1000 samples - for(unsigned i=0;i<1000;i++) { - mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - } - - - mic_array_frame_time_domain *current; - int fd = open("unit_test.expect", O_RDWR | O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); - - // Save the next 1000 samples - for(unsigned i=0;i<1000;i++) { - current = mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - for (int m=0; mdata[m][0]), 4); - } - } - } - - close(fd); - - _Exit(0); - - } - } - return 0; -} diff --git a/tests/unit_tests/generate_output/mic_array_conf.h b/tests/unit_tests/generate_output/mic_array_conf.h deleted file mode 100644 index 5f49a2b5..00000000 --- a/tests/unit_tests/generate_output/mic_array_conf.h +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -//#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -//#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_FRAME_SIZE 1 -#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_CH0 PIN0 -#define MIC_ARRAY_CH1 PIN4 -#define MIC_ARRAY_CH2 PIN1 -#define MIC_ARRAY_CH3 PIN3 - -#define MIC_DECIMATION_FACTOR 6 -#define MIC_FRAME_BUFFERS 4 -#define MIC_CHANNELS 4 -#define MIC_DECIMATORS 1 - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/tests/unit_tests/generate_output/wscript b/tests/unit_tests/generate_output/wscript deleted file mode 100644 index 2e8b9561..00000000 --- a/tests/unit_tests/generate_output/wscript +++ /dev/null @@ -1,19 +0,0 @@ -def options(opt): - opt.load('xwaf.xcommon') - - -def configure(conf): - conf.env.PROJECT_ROOT = "../../../.." - conf.load('xwaf.xcommon') - - -def build(bld): - bld.do_xcommon() - - -def dist(dst): - dst.load('xwaf.xcommon') - - -def distcheck(dst): - dst.load('xwaf.xcommon') diff --git a/tests/unit_tests/src/frontend_debug.h b/tests/unit_tests/src/frontend_debug.h deleted file mode 100644 index f8400e5b..00000000 --- a/tests/unit_tests/src/frontend_debug.h +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright 2017-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. - - -#ifdef __XC__ -#include "mic_array.h" - -void push_random_data(streaming chanend c_pdm_mics); -void audio_frontend_debug_1_dc_no_ref(streaming chanend c_not_a_port, - streaming chanend c_ds_output[]); -void receive_from_mics_init(streaming chanend c_mics[]); -mic_array_frame_time_domain * unsafe get_next_frame(streaming chanend c_mics[]); -void setup_mic_array_decimator(mic_array_decimator_conf_common_t &decimator_common_config, - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS], - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]); - -#endif diff --git a/tests/unit_tests/src/frontend_debug.xc b/tests/unit_tests/src/frontend_debug.xc deleted file mode 100644 index f884001c..00000000 --- a/tests/unit_tests/src/frontend_debug.xc +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include -#include -#include -#include "mic_array.h" - -#define CRC_POLY (0xEB31D82E) - -void pdm_rx_debug( - streaming chanend c_not_a_port, - streaming chanend c_4x_pdm_mic_0, - streaming chanend ?c_4x_pdm_mic_1); - -void push_random_data(streaming chanend c_pdm_mics) { - unsigned x = 1234; - while (1) { - crc32(x, -1, CRC_POLY); - //printf("%d\n", x); - c_pdm_mics <: x; - } -} - -void audio_frontend_debug_1_dc_no_ref(streaming chanend c_not_a_port, - streaming chanend c_ds_output[]) { - streaming chan c_4x_pdm_mic; - - par { - pdm_rx_debug(c_not_a_port, c_4x_pdm_mic, NULL); - mic_array_decimate_to_pcm_4ch(c_4x_pdm_mic, c_ds_output[0], NULL); - } -} - -void setup_mic_array_decimator(mic_array_decimator_conf_common_t &decimator_common_config, - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS], - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]) { - unsafe { -#if MIC_ARRAY_FRAME_SIZE < 16 -// Comment taken from mic_array.h -/**< If len is less than 16 then this sets the frame size to 2 to the power of len, i.e. A frame will contain 2 to the power of len samples of each channel. - If len is 16 or greater then the frame size is equal to len. */ - - decimator_common_config.len = MIC_ARRAY_MAX_FRAME_SIZE_LOG2; -#else - decimator_common_config.len = MIC_ARRAY_FRAME_SIZE; -#endif - decimator_common_config.apply_dc_offset_removal = 1; - decimator_common_config.index_bit_reversal = 0; - decimator_common_config.windowing_function = null; - decimator_common_config.output_decimation_factor = MIC_DECIMATION_FACTOR; - decimator_common_config.coefs = g_third_stage_div_6_fir; // 16kHz - decimator_common_config.apply_mic_gain_compensation = 0; - decimator_common_config.fir_gain_compensation = FIR_COMPENSATOR_DIV_6; // 16kHz - decimator_common_config.buffering_type = DECIMATOR_NO_FRAME_OVERLAP; - decimator_common_config.number_of_frame_buffers = MIC_FRAME_BUFFERS; - - decimator_config[0].dcc = &decimator_common_config; - decimator_config[0].data = mic_array_data[0]; - decimator_config[0].mic_gain_compensation[0]=0; - decimator_config[0].mic_gain_compensation[1]=0; - decimator_config[0].mic_gain_compensation[2]=0; - decimator_config[0].mic_gain_compensation[3]=0; - decimator_config[0].channel_count = MIC_CHANNELS; - //decimator_config[0].async_interface_enabled = 1; - } -} diff --git a/tests/unit_tests/src/test_async_interface/mic_array_conf.h b/tests/unit_tests/src/test_async_interface/mic_array_conf.h deleted file mode 100644 index 4af612b2..00000000 --- a/tests/unit_tests/src/test_async_interface/mic_array_conf.h +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -#define MIC_ARRAY_FRAME_SIZE 1 - -#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_CH0 PIN0 -#define MIC_ARRAY_CH1 PIN4 -#define MIC_ARRAY_CH2 PIN1 -#define MIC_ARRAY_CH3 PIN3 - -#define MIC_DECIMATION_FACTOR 6 -#define MIC_FRAME_BUFFERS 4 -#define MIC_CHANNELS 4 -#define MIC_DECIMATORS 1 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/tests/unit_tests/src/test_async_interface/test_async_interface.xc b/tests/unit_tests/src/test_async_interface/test_async_interface.xc deleted file mode 100644 index e6211421..00000000 --- a/tests/unit_tests/src/test_async_interface/test_async_interface.xc +++ /dev/null @@ -1,76 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "unity.h" -#include "math.h" -#include "string.h" -#include "stdlib.h" -#include "mic_array.h" -#include "frontend_debug.h" - -#include -#include -#include - - -void test_async_interface() { - streaming chan c_pdm_mics; - streaming chan c_ds_output[1]; - - // Mic array state - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - unsigned mic_buffer_index = 0; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - mic_array_decimator_conf_common_t decimator_common_config; - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS]; - - par { - audio_frontend_debug_1_dc_no_ref(c_pdm_mics, c_ds_output); - push_random_data(c_pdm_mics); - { - setup_mic_array_decimator(decimator_common_config, decimator_config, - mic_array_data); - decimator_config[0].async_interface_enabled = 1; - mic_array_decimator_configure(c_ds_output, - MIC_DECIMATORS, - decimator_config); - mic_array_init_time_domain_frame(c_ds_output, - MIC_DECIMATORS, - mic_buffer_index, - audio_frame, - decimator_config); - - int fd = open("unit_test.expect", O_RDONLY); - - mic_array_frame_time_domain *current; - // Global sample index - unsigned g_idx = 0; - while(1) { - int ch_a, ch_b, err; - do { - err = mic_array_recv_samples(c_ds_output[0], ch_a, ch_b); - } while (err); - if (g_idx >= 1000) { - for (int m=0; m -#include -#include - - -void test_frame_size() { - streaming chan c_pdm_mics; - streaming chan c_ds_output[1]; - - // Mic array state - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - unsigned mic_buffer_index = 0; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - mic_array_decimator_conf_common_t decimator_common_config; - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS]; - - par { - audio_frontend_debug_1_dc_no_ref(c_pdm_mics, c_ds_output); - push_random_data(c_pdm_mics); - { - setup_mic_array_decimator(decimator_common_config, decimator_config, - mic_array_data); - mic_array_decimator_configure(c_ds_output, - MIC_DECIMATORS, - decimator_config); - mic_array_init_time_domain_frame(c_ds_output, - MIC_DECIMATORS, - mic_buffer_index, - audio_frame, - decimator_config); - - int fd = open("unit_test.expect", O_RDONLY); - - mic_array_frame_time_domain *current; - // Global sample index - unsigned g_idx = 0; - while(1) { - current = mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - for (int i=0; i= 1000) { - for (int m=0; mdata[m][i]); - } - } - g_idx++; - if (g_idx == 2000) { - // Exit successfully - close(fd); - UnityConcludeTest(); - _Exit(0); - } - } - } - } - } -} diff --git a/tests/unit_tests/src/test_frame_size_16/mic_array_conf.h b/tests/unit_tests/src/test_frame_size_16/mic_array_conf.h deleted file mode 100644 index fad811f2..00000000 --- a/tests/unit_tests/src/test_frame_size_16/mic_array_conf.h +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 4 -#define MIC_ARRAY_FRAME_SIZE 16 - -#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_CH0 PIN0 -#define MIC_ARRAY_CH1 PIN4 -#define MIC_ARRAY_CH2 PIN1 -#define MIC_ARRAY_CH3 PIN3 - -#define MIC_DECIMATION_FACTOR 6 -#define MIC_FRAME_BUFFERS 4 -#define MIC_CHANNELS 4 -#define MIC_DECIMATORS 1 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/tests/unit_tests/src/test_frame_size_16/test_frame_size_16.xc b/tests/unit_tests/src/test_frame_size_16/test_frame_size_16.xc deleted file mode 100644 index 91a475f4..00000000 --- a/tests/unit_tests/src/test_frame_size_16/test_frame_size_16.xc +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "unity.h" -#include "math.h" -#include "string.h" -#include "stdlib.h" -#include "mic_array.h" -#include "frontend_debug.h" - -#include -#include -#include - - -void test_frame_size() { - streaming chan c_pdm_mics; - streaming chan c_ds_output[1]; - - // Mic array state - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - unsigned mic_buffer_index = 0; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - mic_array_decimator_conf_common_t decimator_common_config; - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS]; - - par { - audio_frontend_debug_1_dc_no_ref(c_pdm_mics, c_ds_output); - push_random_data(c_pdm_mics); - { - setup_mic_array_decimator(decimator_common_config, decimator_config, - mic_array_data); - mic_array_decimator_configure(c_ds_output, - MIC_DECIMATORS, - decimator_config); - mic_array_init_time_domain_frame(c_ds_output, - MIC_DECIMATORS, - mic_buffer_index, - audio_frame, - decimator_config); - - int fd = open("unit_test.expect", O_RDONLY); - - mic_array_frame_time_domain *current; - // Global sample index - unsigned g_idx = 0; - while(1) { - current = mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - for (int i=0; i= 1000) { - for (int m=0; mdata[m][i]); - } - } - g_idx++; - if (g_idx == 2000) { - // Exit successfully - close(fd); - UnityConcludeTest(); - _Exit(0); - } - } - } - } - } -} diff --git a/tests/unit_tests/src/test_frame_size_240/mic_array_conf.h b/tests/unit_tests/src/test_frame_size_240/mic_array_conf.h deleted file mode 100644 index be57e28c..00000000 --- a/tests/unit_tests/src/test_frame_size_240/mic_array_conf.h +++ /dev/null @@ -1,24 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -//#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -//#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 8 -#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_CH0 PIN0 -#define MIC_ARRAY_CH1 PIN4 -#define MIC_ARRAY_CH2 PIN1 -#define MIC_ARRAY_CH3 PIN3 - -#define MIC_DECIMATION_FACTOR 6 -#define MIC_FRAME_BUFFERS 4 -#define MIC_CHANNELS 4 -#define MIC_DECIMATORS 1 -#define MIC_ARRAY_FRAME_SIZE 256 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/tests/unit_tests/src/test_frame_size_240/test_frame_size_240.xc b/tests/unit_tests/src/test_frame_size_240/test_frame_size_240.xc deleted file mode 100644 index 91a475f4..00000000 --- a/tests/unit_tests/src/test_frame_size_240/test_frame_size_240.xc +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "unity.h" -#include "math.h" -#include "string.h" -#include "stdlib.h" -#include "mic_array.h" -#include "frontend_debug.h" - -#include -#include -#include - - -void test_frame_size() { - streaming chan c_pdm_mics; - streaming chan c_ds_output[1]; - - // Mic array state - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - unsigned mic_buffer_index = 0; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - mic_array_decimator_conf_common_t decimator_common_config; - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS]; - - par { - audio_frontend_debug_1_dc_no_ref(c_pdm_mics, c_ds_output); - push_random_data(c_pdm_mics); - { - setup_mic_array_decimator(decimator_common_config, decimator_config, - mic_array_data); - mic_array_decimator_configure(c_ds_output, - MIC_DECIMATORS, - decimator_config); - mic_array_init_time_domain_frame(c_ds_output, - MIC_DECIMATORS, - mic_buffer_index, - audio_frame, - decimator_config); - - int fd = open("unit_test.expect", O_RDONLY); - - mic_array_frame_time_domain *current; - // Global sample index - unsigned g_idx = 0; - while(1) { - current = mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - for (int i=0; i= 1000) { - for (int m=0; mdata[m][i]); - } - } - g_idx++; - if (g_idx == 2000) { - // Exit successfully - close(fd); - UnityConcludeTest(); - _Exit(0); - } - } - } - } - } -} diff --git a/tests/unit_tests/src/test_frame_size_256/mic_array_conf.h b/tests/unit_tests/src/test_frame_size_256/mic_array_conf.h deleted file mode 100644 index be57e28c..00000000 --- a/tests/unit_tests/src/test_frame_size_256/mic_array_conf.h +++ /dev/null @@ -1,24 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -//#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -//#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 8 -#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_CH0 PIN0 -#define MIC_ARRAY_CH1 PIN4 -#define MIC_ARRAY_CH2 PIN1 -#define MIC_ARRAY_CH3 PIN3 - -#define MIC_DECIMATION_FACTOR 6 -#define MIC_FRAME_BUFFERS 4 -#define MIC_CHANNELS 4 -#define MIC_DECIMATORS 1 -#define MIC_ARRAY_FRAME_SIZE 256 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/tests/unit_tests/src/test_frame_size_256/test_frame_size_256.xc b/tests/unit_tests/src/test_frame_size_256/test_frame_size_256.xc deleted file mode 100644 index 91a475f4..00000000 --- a/tests/unit_tests/src/test_frame_size_256/test_frame_size_256.xc +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "unity.h" -#include "math.h" -#include "string.h" -#include "stdlib.h" -#include "mic_array.h" -#include "frontend_debug.h" - -#include -#include -#include - - -void test_frame_size() { - streaming chan c_pdm_mics; - streaming chan c_ds_output[1]; - - // Mic array state - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - unsigned mic_buffer_index = 0; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - mic_array_decimator_conf_common_t decimator_common_config; - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS]; - - par { - audio_frontend_debug_1_dc_no_ref(c_pdm_mics, c_ds_output); - push_random_data(c_pdm_mics); - { - setup_mic_array_decimator(decimator_common_config, decimator_config, - mic_array_data); - mic_array_decimator_configure(c_ds_output, - MIC_DECIMATORS, - decimator_config); - mic_array_init_time_domain_frame(c_ds_output, - MIC_DECIMATORS, - mic_buffer_index, - audio_frame, - decimator_config); - - int fd = open("unit_test.expect", O_RDONLY); - - mic_array_frame_time_domain *current; - // Global sample index - unsigned g_idx = 0; - while(1) { - current = mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - for (int i=0; i= 1000) { - for (int m=0; mdata[m][i]); - } - } - g_idx++; - if (g_idx == 2000) { - // Exit successfully - close(fd); - UnityConcludeTest(); - _Exit(0); - } - } - } - } - } -} diff --git a/tests/unit_tests/src/test_pdm_muting/mic_array_conf.h b/tests/unit_tests/src/test_pdm_muting/mic_array_conf.h deleted file mode 100644 index 16c2ae4f..00000000 --- a/tests/unit_tests/src/test_pdm_muting/mic_array_conf.h +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright 2015-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#ifndef MIC_ARRAY_CONF_H_ -#define MIC_ARRAY_CONF_H_ - -//#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 0 -//#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_MAX_FRAME_SIZE_LOG2 4 -#define MIC_ARRAY_NUM_MICS 4 - -#define MIC_ARRAY_CH0 PIN0 -#define MIC_ARRAY_CH1 PIN4 -#define MIC_ARRAY_CH2 PIN1 -#define MIC_ARRAY_CH3 PIN3 - -#define MIC_DECIMATION_FACTOR 6 -#define MIC_FRAME_BUFFERS 4 -#define MIC_CHANNELS 4 -#define MIC_DECIMATORS 1 -#define MIC_ARRAY_FRAME_SIZE 16 - -#define MIC_ARRAY_MUTE_CH_1 1 - - -#endif /* MIC_ARRAY_CONF_H_ */ diff --git a/tests/unit_tests/src/test_pdm_muting/test_pdm_muting.xc b/tests/unit_tests/src/test_pdm_muting/test_pdm_muting.xc deleted file mode 100644 index 172a0edc..00000000 --- a/tests/unit_tests/src/test_pdm_muting/test_pdm_muting.xc +++ /dev/null @@ -1,85 +0,0 @@ -// Copyright 2019-2021 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. -#include "unity.h" -#include "math.h" -#include "string.h" -#include "stdlib.h" -#include "mic_array.h" -#include "frontend_debug.h" - -void test_pdm_muting() { - streaming chan c_pdm_mics; - streaming chan c_ds_output[1]; - - // Mic array state - int mic_array_data[MIC_DECIMATORS*MIC_CHANNELS][THIRD_STAGE_COEFS_PER_STAGE*MIC_DECIMATION_FACTOR]; - unsigned mic_buffer_index = 0; - mic_array_frame_time_domain audio_frame[MIC_FRAME_BUFFERS]; - mic_array_decimator_conf_common_t decimator_common_config; - mic_array_decimator_config_t decimator_config[MIC_DECIMATORS]; - - par { - audio_frontend_debug_1_dc_no_ref(c_pdm_mics, c_ds_output); - push_random_data(c_pdm_mics); - { - setup_mic_array_decimator(decimator_common_config, decimator_config, - mic_array_data); - mic_array_decimator_configure(c_ds_output, - MIC_DECIMATORS, - decimator_config); - mic_array_init_time_domain_frame(c_ds_output, - MIC_DECIMATORS, - mic_buffer_index, - audio_frame, - decimator_config); - - //first wait until the filter delay has passed - for(unsigned i=0;i<64;i++) { - mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - } - - unsigned x; - mic_array_frame_time_domain frame_0; - mic_array_frame_time_domain frame_1; - - mic_array_frame_time_domain *current; - - // Get frame_0 - current = mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - memcpy(&frame_0, current, sizeof(mic_array_frame_time_domain)); - - // Get frame_1 - current = mic_array_get_next_time_domain_frame( - c_ds_output, MIC_DECIMATORS, mic_buffer_index, - audio_frame, decimator_config); - memcpy(&frame_1, current, sizeof(mic_array_frame_time_domain)); - - mic_array_frame_time_domain frame_zero; - // Check that for indices 0 <= i < frame_size - // All values of muted mic == 0 - // And at least one value for non-muted mics is non-zero - int all_zero[4] = {1}; - for (int m=0; m